private unsafe string ProcessOneObject(
object data,
MofField *mofField,
char *ptr,
ref uint offSet)
{
return(this.EncodeObject(data, mofField, ptr, ref offSet));
}
private unsafe string EncodeObject(object data, MofField *mofField, char *ptr, ref uint offSet, byte *ptrArgInfo)
{
if (data == null)
{
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)0; //NULL type, WIN64 Changes
*(ushort *)(ptrArgInfo + 1) = (ushort)0;
}
mofField->DataLength = 0;
mofField->DataPointer = (void *)null; //WIN64 Changes (?)
return(null);
}
// if the data is an enum we'll convert it to its underlying type
Type dataType = data.GetType();
if (dataType.IsEnum)
{
data = Convert.ChangeType(data, Enum.GetUnderlyingType(dataType), CultureInfo.InvariantCulture);
}
string sRet = data as string;
if (sRet != null)
{
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)2; //WIN64 Changes
*(ushort *)(ptrArgInfo + 1) = (ushort)(sRet.Length < 65535 ? sRet.Length : 65535); //WIN64 Changes
}
else
{ // TraceEvent path. Need counted strings.
mofField->DataLength = sizeof(ushort);
ushort *ushortptr = (ushort *)ptr;
* ushortptr = (ushort)(sRet.Length * 2 < 65535 ? sRet.Length * 2 : 65535);
mofField->DataPointer = (void *)ushortptr;
offSet += sizeof(ushort);
}
return(sRet);
}
if (data is sbyte)
{
mofField->DataLength = sizeof(sbyte);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)3; //WIN64 Changes
}
sbyte *sbyteptr = (sbyte *)ptr;
* sbyteptr = (sbyte)data; //WIN64 Changes
mofField->DataPointer = (void *)sbyteptr;
offSet += sizeof(sbyte);
}
else if (data is byte)
{
mofField->DataLength = sizeof(byte);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)4; //WIN64 Changes
}
byte *byteptr = (byte *)ptr;
* byteptr = (byte)data; //WIN64 Changes
mofField->DataPointer = (void *)byteptr;
offSet += sizeof(byte);
}
else if (data is short)
{
mofField->DataLength = sizeof(short);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)5; //WIN64 Changes
}
short *shortptr = (short *)ptr;
* shortptr = (short)data; //WIN64 Changes
mofField->DataPointer = (void *)shortptr;
offSet += sizeof(short);
}
else if (data is ushort)
{
mofField->DataLength = sizeof(ushort);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)6; //WIN64 Changes
}
ushort *ushortptr = (ushort *)ptr;
* ushortptr = (ushort)data; //WIN64 Changes
mofField->DataPointer = (void *)ushortptr;
offSet += sizeof(ushort);
}
else if (data is int)
{
mofField->DataLength = sizeof(int);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)7; //WIN64 Changes
}
int *intptr = (int *)ptr;
* intptr = (int)data; //WIN64 Changes
mofField->DataPointer = (void *)intptr;
offSet += sizeof(int);
}
else if (data is uint)
{
mofField->DataLength = sizeof(uint);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)8; //WIN64 Changes
}
uint *uintptr = (uint *)ptr;
* uintptr = (uint)data; //WIN64 Changes
mofField->DataPointer = (void *)uintptr;
offSet += sizeof(uint);
}
else if (data is long)
{
mofField->DataLength = sizeof(long);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)9; //WIN64 Changes
}
long *longptr = (long *)ptr;
* longptr = (long)data; //WIN64 Changes
mofField->DataPointer = (void *)longptr;
offSet += sizeof(long);
}
else if (data is ulong)
{
mofField->DataLength = sizeof(ulong);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)10; //WIN64 Changes
}
ulong *ulongptr = (ulong *)ptr;
* ulongptr = (ulong)data; //WIN64 Changes
mofField->DataPointer = (void *)ulongptr;
offSet += sizeof(ulong);
}
else if (data is char)
{
mofField->DataLength = sizeof(char);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)11; //WIN64 Changes
}
char *charptr = (char *)ptr;
* charptr = (char)data; //WIN64 Changes
mofField->DataPointer = (void *)charptr;
offSet += sizeof(char);
}
else if (data is float)
{
mofField->DataLength = sizeof(float);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)12; //WIN64 Changes
}
float *floatptr = (float *)ptr;
* floatptr = (float)data; //WIN64 Changes
mofField->DataPointer = (void *)floatptr;
offSet += sizeof(float);
}
else if (data is double)
{
mofField->DataLength = sizeof(double);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)13; //WIN64 Changes
}
double *doubleptr = (double *)ptr;
* doubleptr = (double)data; //WIN64 Changes
mofField->DataPointer = (void *)doubleptr;
offSet += sizeof(double);
}
else if (data is bool)
{
mofField->DataLength = sizeof(bool);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)14; //WIN64 Changes
}
bool *boolptr = (bool *)ptr;
* boolptr = (bool)data; //WIN64 Changes
mofField->DataPointer = (void *)boolptr;
offSet += sizeof(bool);
}
else if (data is decimal)
{
mofField->DataLength = (uint)sizeof(decimal);
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)15; //WIN64 Changes
}
decimal *decimalptr = (decimal *)ptr;
* decimalptr = (decimal)data; //WIN64 Changes
mofField->DataPointer = (void *)decimalptr;
offSet += (uint)sizeof(decimal);
}
else
{
//To our eyes, everything else is a just a string
sRet = data.ToString();
if (ptrArgInfo != null)
{
*ptrArgInfo = (byte)2; //WIN64 Changes
*(ushort *)(ptrArgInfo + 1) = (ushort)(sRet.Length < 65535 ? sRet.Length : 65535); //WIN64 Changes
}
else
{ // TraceEvent path. Need counted strings.
mofField->DataLength = sizeof(ushort);
ushort *ushortptr = (ushort *)ptr;
* ushortptr = (ushort)(sRet.Length * 2 < 65535 ? sRet.Length * 2 : 65535);
mofField->DataPointer = (void *)ushortptr;
offSet += sizeof(ushort);
}
return(sRet);
}
if (ptrArgInfo != null)
{
*(ushort *)(ptrArgInfo + 1) = (ushort)(mofField->DataLength); //WIN64 Changes (?)
}
return(sRet);
}
private unsafe uint TraceEvent(
EventTrace.Level level, Guid eventGuid, byte evtype,
object data0, object data1, object data2, object data3, object data4, object data5, object data6, object data7, object data8)
{
uint status = 0;
BaseEvent ev; // Takes up 304 bytes on the stack
// The largest possible item stored in this buffer from each of data0
// through data8 will be a decimal (strings are logged as pointers)
const uint bufferSize = sizeof(decimal) * 9;
char * buffer = stackalloc char[(int)bufferSize];
uint offset = 0;
char * ptr = buffer;
string s0, s1, s2, s3, s4, s5, s6, s7, s8;
int stringMask = 0;
uint argCount = 0;
int mofIndex = 0;
s0 = s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = "";
ev.ClientContext = 0;
ev.Flags = 0x00120000; // define Constants
ev.Guid = eventGuid;
ev.EventType = evtype;
ev.Level = level;
ev.Version = _version;
MofField *be = null;
if (data0 != null)
{
argCount++;
be = &(&ev.UserData)[mofIndex++];
if ((s0 = ProcessOneObject(data0, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000001;
mofIndex++; // Leave a slot for the String Pointer
}
}
if (data1 != null)
{
argCount++;
be = &(&ev.UserData)[mofIndex++];
ptr = buffer + offset;
if ((s1 = ProcessOneObject(data1, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000002;
mofIndex++; // Leave a slot for the String Pointer
}
}
if (data2 != null)
{
argCount++;
be = &(&ev.UserData)[mofIndex++];
ptr = buffer + offset;
if ((s2 = ProcessOneObject(data2, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000004;
mofIndex++; // Leave a slot for the String Pointer
}
}
if (data3 != null)
{
argCount++;
be = &(&ev.UserData)[mofIndex++];
ptr = buffer + offset;
if ((s3 = ProcessOneObject(data3, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000008;
mofIndex++; // Leave a slot for the String Pointer
}
}
if (data4 != null)
{
argCount++;
be = &(&ev.UserData)[mofIndex++];
ptr = buffer + offset;
if ((s4 = ProcessOneObject(data4, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000010;
mofIndex++; // Leave a slot for the String Pointer
}
}
if (data5 != null)
{
argCount++;
be = &(&ev.UserData)[mofIndex++];
ptr = buffer + offset;
if ((s5 = ProcessOneObject(data5, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000020;
mofIndex++; // Leave a slot for the String Pointer
}
}
if (data6 != null)
{
argCount++;
be = &(&ev.UserData)[mofIndex++];
ptr = buffer + offset;
if ((s6 = ProcessOneObject(data6, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000040;
mofIndex++; // Leave a slot for the String Pointer
}
}
if (data7 != null)
{
argCount++;
be = &(&ev.UserData)[mofIndex++];
ptr = buffer + offset;
if ((s7 = ProcessOneObject(data7, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000080;
mofIndex++; // Leave a slot for the String Pointer
}
}
if (data8 != null)
{
argCount++;
be = &(&ev.UserData)[mofIndex++];
ptr = buffer + offset;
if ((s8 = ProcessOneObject(data8, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000100;
mofIndex++; // Leave a slot for the String Pointer
}
}
// Assert we haven't exceeded the buffer size
Debug.Assert(ptr - buffer <= bufferSize);
// Now pin all the strings and use the stringMask to pass them over through mofField
fixed(char *vptr0 = s0, vptr1 = s1, vptr2 = s2, vptr3 = s3, vptr4 = s4, vptr5 = s5, vptr6 = s6, vptr7 = s7, vptr8 = s8)
{
int i = 0;
if ((stringMask & 0x00000001) != 0)
{
i++;
(&ev.UserData)[i].DataLength = (uint)s0.Length * 2;
(&ev.UserData)[i].DataPointer = (void *)vptr0;
}
i++;
if ((stringMask & 0x00000002) != 0)
{
i++;
(&ev.UserData)[i].DataLength = (uint)s1.Length * 2;
(&ev.UserData)[i].DataPointer = (void *)vptr1;
}
i++;
if ((stringMask & 0x00000004) != 0)
{
i++;
(&ev.UserData)[i].DataLength = (uint)s2.Length * 2;
(&ev.UserData)[i].DataPointer = (void *)vptr2;
}
i++;
if ((stringMask & 0x00000008) != 0)
{
i++;
(&ev.UserData)[i].DataLength = (uint)s3.Length * 2;
(&ev.UserData)[i].DataPointer = (void *)vptr3;
}
i++;
if ((stringMask & 0x00000010) != 0)
{
i++;
(&ev.UserData)[i].DataLength = (uint)s4.Length * 2;
(&ev.UserData)[i].DataPointer = (void *)vptr4;
}
i++;
if ((stringMask & 0x00000020) != 0)
{
i++;
(&ev.UserData)[i].DataLength = (uint)s5.Length * 2;
(&ev.UserData)[i].DataPointer = (void *)vptr5;
}
i++;
if ((stringMask & 0x00000040) != 0)
{
i++;
(&ev.UserData)[i].DataLength = (uint)s6.Length * 2;
(&ev.UserData)[i].DataPointer = (void *)vptr6;
}
i++;
if ((stringMask & 0x00000080) != 0)
{
i++;
(&ev.UserData)[i].DataLength = (uint)s7.Length * 2;
(&ev.UserData)[i].DataPointer = (void *)vptr7;
}
i++;
if ((stringMask & 0x00000100) != 0)
{
i++;
(&ev.UserData)[i].DataLength = (uint)s8.Length * 2;
(&ev.UserData)[i].DataPointer = (void *)vptr8;
}
ev.BufferSize = 48 + (uint)mofIndex * (uint)sizeof(MofField);
status = EtwTrace.TraceEvent(_traceHandle, (char *)&ev);
}
return(status);
}
private unsafe string EncodeObject(
object data,
MofField *mofField,
char *ptr,
ref uint offSet)
{
if (data == null)
{
mofField->DataLength = 0U;
mofField->DataPointer = null;
return(null);
}
Type type = data.GetType();
if (type.IsEnum)
{
data = Convert.ChangeType(data, Enum.GetUnderlyingType(type), CultureInfo.InvariantCulture);
}
switch (data)
{
case sbyte num:
mofField->DataLength = 1U;
sbyte *numPtr1 = (sbyte *)ptr;
* numPtr1 = num;
mofField->DataPointer = numPtr1;
++offSet;
break;
case byte num:
mofField->DataLength = 1U;
byte *numPtr2 = (byte *)ptr;
* numPtr2 = num;
mofField->DataPointer = numPtr2;
++offSet;
break;
case short num:
mofField->DataLength = 2U;
short *numPtr3 = (short *)ptr;
* numPtr3 = num;
mofField->DataPointer = numPtr3;
offSet += 2U;
break;
case ushort num:
mofField->DataLength = 2U;
ushort *numPtr4 = (ushort *)ptr;
* numPtr4 = num;
mofField->DataPointer = numPtr4;
offSet += 2U;
break;
case int num:
mofField->DataLength = 4U;
int *numPtr5 = (int *)ptr;
* numPtr5 = num;
mofField->DataPointer = numPtr5;
offSet += 4U;
break;
case uint num:
mofField->DataLength = 4U;
uint *numPtr6 = (uint *)ptr;
* numPtr6 = num;
mofField->DataPointer = numPtr6;
offSet += 4U;
break;
case long num:
mofField->DataLength = 8U;
long *numPtr7 = (long *)ptr;
* numPtr7 = num;
mofField->DataPointer = numPtr7;
offSet += 8U;
break;
case ulong num:
mofField->DataLength = 8U;
ulong *numPtr8 = (ulong *)ptr;
* numPtr8 = num;
mofField->DataPointer = numPtr8;
offSet += 8U;
break;
case char ch:
mofField->DataLength = 2U;
char *chPtr = ptr;
* chPtr = ch;
mofField->DataPointer = chPtr;
offSet += 2U;
break;
case float num:
mofField->DataLength = 4U;
float *numPtr9 = (float *)ptr;
* numPtr9 = num;
mofField->DataPointer = numPtr9;
offSet += 4U;
break;
case double num:
mofField->DataLength = 8U;
double *numPtr10 = (double *)ptr;
* numPtr10 = num;
mofField->DataPointer = numPtr10;
offSet += 8U;
break;
case bool flag:
mofField->DataLength = 1U;
bool *flagPtr = (bool *)ptr;
* flagPtr = flag;
mofField->DataPointer = flagPtr;
++offSet;
break;
case Decimal num:
mofField->DataLength = 16U;
Decimal *numPtr11 = (Decimal *)ptr;
* numPtr11 = num;
mofField->DataPointer = numPtr11;
offSet += 16U;
break;
default:
return(data.ToString());
}
return(null);
}
internal unsafe uint TraceEvent(
byte level,
Guid eventGuid,
byte evtype,
object data0,
object data1,
object data2,
object data3,
object data4,
object data5,
object data6,
object data7,
object data8)
{
char * chPtr1 = stackalloc char[144];
uint offSet = 0;
char * ptr = chPtr1;
int num1 = 0;
uint num2 = 0;
int num3 = 0;
string str1;
string str2 = str1 = "";
string str3 = str1;
string str4 = str1;
string str5 = str1;
string str6 = str1;
string str7 = str1;
string str8 = str1;
string str9 = str1;
string str10 = str1;
BaseEvent baseEvent;
baseEvent.ClientContext = 0U;
baseEvent.Flags = 1179648U;
baseEvent.Guid = eventGuid;
baseEvent.EventType = evtype;
baseEvent.Level = level;
baseEvent.Version = 0;
if (data0 != null)
{
++num2;
MofField *mofField = &baseEvent.UserData + num3++ *sizeof(MofField);
if ((str10 = this.ProcessOneObject(data0, mofField, ptr, ref offSet)) != null)
{
num1 |= 1;
}
}
if (data1 != null)
{
++num2;
MofField *mofField = &baseEvent.UserData + num3++ *sizeof(MofField);
ptr = chPtr1 + offSet;
if ((str9 = this.ProcessOneObject(data1, mofField, ptr, ref offSet)) != null)
{
num1 |= 2;
}
}
if (data2 != null)
{
++num2;
MofField *mofField = &baseEvent.UserData + num3++ *sizeof(MofField);
ptr = chPtr1 + offSet;
if ((str8 = this.ProcessOneObject(data2, mofField, ptr, ref offSet)) != null)
{
num1 |= 4;
}
}
if (data3 != null)
{
++num2;
MofField *mofField = &baseEvent.UserData + num3++ *sizeof(MofField);
ptr = chPtr1 + offSet;
if ((str7 = this.ProcessOneObject(data3, mofField, ptr, ref offSet)) != null)
{
num1 |= 8;
}
}
if (data4 != null)
{
++num2;
MofField *mofField = &baseEvent.UserData + num3++ *sizeof(MofField);
ptr = chPtr1 + offSet;
if ((str6 = this.ProcessOneObject(data4, mofField, ptr, ref offSet)) != null)
{
num1 |= 16;
}
}
if (data5 != null)
{
++num2;
MofField *mofField = &baseEvent.UserData + num3++ *sizeof(MofField);
ptr = chPtr1 + offSet;
if ((str5 = this.ProcessOneObject(data5, mofField, ptr, ref offSet)) != null)
{
num1 |= 32;
}
}
if (data6 != null)
{
++num2;
MofField *mofField = &baseEvent.UserData + num3++ *sizeof(MofField);
ptr = chPtr1 + offSet;
if ((str4 = this.ProcessOneObject(data6, mofField, ptr, ref offSet)) != null)
{
num1 |= 64;
}
}
if (data7 != null)
{
++num2;
MofField *mofField = &baseEvent.UserData + num3++ *sizeof(MofField);
ptr = chPtr1 + offSet;
if ((str3 = this.ProcessOneObject(data7, mofField, ptr, ref offSet)) != null)
{
num1 |= 128;
}
}
if (data8 != null)
{
uint num4 = num2 + 1U;
MofField *mofField = &baseEvent.UserData + num3++ *sizeof(MofField);
ptr = chPtr1 + offSet;
if ((str2 = this.ProcessOneObject(data8, mofField, ptr, ref offSet)) != null)
{
num1 |= 256;
}
}
if (ptr - chPtr1 > 144L)
{
return(1);
}
uint num5;
fixed(char *chPtr2 = str10)
fixed(char *chPtr3 = str9)
fixed(char *chPtr4 = str8)
fixed(char *chPtr5 = str7)
fixed(char *chPtr6 = str6)
fixed(char *chPtr7 = str5)
fixed(char *chPtr8 = str4)
fixed(char *chPtr9 = str3)
fixed(char *chPtr10 = str2)
{
int index1 = 0;
if ((num1 & 1) != 0)
{
(&baseEvent.UserData)[index1].DataLength = (uint)((str10.Length + 1) * 2);
(&baseEvent.UserData)[index1].DataPointer = chPtr2;
}
int index2 = index1 + 1;
if ((num1 & 2) != 0)
{
(&baseEvent.UserData)[index2].DataLength = (uint)((str9.Length + 1) * 2);
(&baseEvent.UserData)[index2].DataPointer = chPtr3;
}
int index3 = index2 + 1;
if ((num1 & 4) != 0)
{
(&baseEvent.UserData)[index3].DataLength = (uint)((str8.Length + 1) * 2);
(&baseEvent.UserData)[index3].DataPointer = chPtr4;
}
int index4 = index3 + 1;
if ((num1 & 8) != 0)
{
(&baseEvent.UserData)[index4].DataLength = (uint)((str7.Length + 1) * 2);
(&baseEvent.UserData)[index4].DataPointer = chPtr5;
}
int index5 = index4 + 1;
if ((num1 & 16) != 0)
{
(&baseEvent.UserData)[index5].DataLength = (uint)((str6.Length + 1) * 2);
(&baseEvent.UserData)[index5].DataPointer = chPtr6;
}
int index6 = index5 + 1;
if ((num1 & 32) != 0)
{
(&baseEvent.UserData)[index6].DataLength = (uint)((str5.Length + 1) * 2);
(&baseEvent.UserData)[index6].DataPointer = chPtr7;
}
int index7 = index6 + 1;
if ((num1 & 64) != 0)
{
(&baseEvent.UserData)[index7].DataLength = (uint)((str4.Length + 1) * 2);
(&baseEvent.UserData)[index7].DataPointer = chPtr8;
}
int index8 = index7 + 1;
if ((num1 & 128) != 0)
{
(&baseEvent.UserData)[index8].DataLength = (uint)((str3.Length + 1) * 2);
(&baseEvent.UserData)[index8].DataPointer = chPtr9;
}
int index9 = index8 + 1;
if ((num1 & 256) != 0)
{
(&baseEvent.UserData)[index9].DataLength = (uint)((str2.Length + 1) * 2);
(&baseEvent.UserData)[index9].DataPointer = chPtr10;
}
baseEvent.BufferSize = (uint)(48 + num3 * sizeof(MofField));
num5 = TraceEvent(this._traceHandle, (char *)&baseEvent);
}
return(num5);
}
private unsafe uint EncodeTraceMessage(Guid eventGuid, uint evtype, byte nargs, object formatstring, object data2, object data3, object data4, object data5, object data6, object data7, object data8, object data9)
{
uint status = 0;
BaseEvent ev; // Takes up 208 bytes on the stack
char * buffer = stackalloc char[144 + (1 + 9 * noOfBytesPerArg) / sizeof(char)]; //28 characters would be 56 bytes!!!. We are allocating more space than we require.
//Header structure:
//1 byte for number of args
//3 byte for format string type information,
//3 bytes each for the type information for a maximum of 8 arguments
byte * header = (byte *)(buffer + 144);
uint offset = 0;
char * ptr = buffer;
string s1, s2, s3, s4, s5, s6, s7, s8, s9;
int stringMask = 0;
uint argCount = 0;
byte * ptrHeader = header;
s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = s9 = defaultString;
ev.Flags = 0x00120000; // define Constants
ev.Guid = eventGuid;
//IMP: evtype MUST be the same as the one specified in the typeve field for CSharp in default.tmf
ev.ProviderId = evtype;
MofField *be = null;
if (header != null)
{
be = &(&ev.UserData)[0];
header[0] = (byte)nargs; //WIN64 Changes (?)
be->DataPointer = (void *)header;
be->DataLength = (uint)(1 + nargs * noOfBytesPerArg);
}
if (formatstring == null)
{
formatstring = defaultFmtStr;
}
if (formatstring != null)
{
//data1 would, in most cases, be the format string
argCount++;
be = &(&ev.UserData)[1];
ptr = buffer + offset;
if ((s1 = EncodeObject(formatstring, be, ptr, ref offset, ++header)) != null)
{
stringMask |= 0x00000002;
}
}
if (argCount <= nargs)
{
argCount++;
be = &(&ev.UserData)[2];
ptr = buffer + offset;
if ((s2 = EncodeObject(data2, be, ptr, ref offset, header + 1 * noOfBytesPerArg)) != null)
{
stringMask |= 0x00000004;
}
}
if (argCount <= nargs)
{
argCount++;
be = &(&ev.UserData)[3];
ptr = buffer + offset;
if ((s3 = EncodeObject(data3, be, ptr, ref offset, header + 2 * noOfBytesPerArg)) != null)
{
stringMask |= 0x00000008;
}
}
if (argCount <= nargs)
{
argCount++;
be = &(&ev.UserData)[4];
ptr = buffer + offset;
if ((s4 = EncodeObject(data4, be, ptr, ref offset, header + 3 * noOfBytesPerArg)) != null)
{
stringMask |= 0x00000010;
}
}
if (argCount <= nargs)
{
argCount++;
be = &(&ev.UserData)[5];
ptr = buffer + offset;
if ((s5 = EncodeObject(data5, be, ptr, ref offset, header + 4 * noOfBytesPerArg)) != null)
{
stringMask |= 0x00000020;
}
}
if (argCount <= nargs)
{
argCount++;
be = &(&ev.UserData)[6];
ptr = buffer + offset;
if ((s6 = EncodeObject(data6, be, ptr, ref offset, header + 5 * noOfBytesPerArg)) != null)
{
stringMask |= 0x00000040;
}
}
if (argCount <= nargs)
{
argCount++;
be = &(&ev.UserData)[7];
ptr = buffer + offset;
if ((s7 = EncodeObject(data7, be, ptr, ref offset, header + 6 * noOfBytesPerArg)) != null)
{
stringMask |= 0x00000080;
}
}
if (argCount <= nargs)
{
argCount++;
be = &(&ev.UserData)[8];
ptr = buffer + offset;
if ((s8 = EncodeObject(data8, be, ptr, ref offset, header + 7 * noOfBytesPerArg)) != null)
{
stringMask |= 0x00000100;
}
}
if (argCount <= nargs)
{
argCount++;
be = &(&ev.UserData)[9];
ptr = buffer + offset;
if ((s9 = EncodeObject(data9, be, ptr, ref offset, header + 8 * noOfBytesPerArg)) != null)
{
stringMask |= 0x00000200;
}
}
//
// Now pin all the strings and use the stringMask to pass them over through
// mofField.
//
fixed(char *vptr1 = s1, vptr2 = s2, vptr3 = s3, vptr4 = s4, vptr5 = s5, vptr6 = s6, vptr7 = s7, vptr8 = s8, vptr9 = s9)
{
if ((stringMask & 0x00000002) != 0)
{
(&ev.UserData)[1].DataLength = (uint)(s1.Length < 65535 / 2?s1.Length * 2:65535); //s1.Length*2;
(&ev.UserData)[1].DataPointer = (void *)(vptr1);
}
if ((stringMask & 0x00000004) != 0)
{
(&ev.UserData)[2].DataLength = (uint)(s2.Length < 65535 / 2?s2.Length * 2:65535); //s2.Length * 2;
(&ev.UserData)[2].DataPointer = (void *)(vptr2);
}
if ((stringMask & 0x00000008) != 0)
{
(&ev.UserData)[3].DataLength = (uint)(s3.Length < 65535 / 2?s3.Length * 2:65535); //s3.Length * 2;
(&ev.UserData)[3].DataPointer = (void *)(vptr3);
}
if ((stringMask & 0x00000010) != 0)
{
(&ev.UserData)[4].DataLength = (uint)(s4.Length < 65535 / 2?s4.Length * 2:65535); //s4.Length * 2;
(&ev.UserData)[4].DataPointer = (void *)(vptr4);
}
if ((stringMask & 0x00000020) != 0)
{
(&ev.UserData)[5].DataLength = (uint)(s5.Length < 65535 / 2?s5.Length * 2:65535); //s5.Length * 2;
(&ev.UserData)[5].DataPointer = (void *)(vptr5);
}
if ((stringMask & 0x00000040) != 0)
{
(&ev.UserData)[6].DataLength = (uint)(s6.Length < 65535 / 2?s6.Length * 2:65535); //s6.Length * 2;
(&ev.UserData)[6].DataPointer = (void *)(vptr6);
}
if ((stringMask & 0x00000080) != 0)
{
(&ev.UserData)[7].DataLength = (uint)(s7.Length < 65535 / 2?s7.Length * 2:65535); //s7.Length * 2;
(&ev.UserData)[7].DataPointer = (void *)(vptr7);
}
if ((stringMask & 0x00000100) != 0)
{
(&ev.UserData)[8].DataLength = (uint)(s8.Length < 65535 / 2?s8.Length * 2:65535); //s8.Length * 2;
(&ev.UserData)[8].DataPointer = (void *)(vptr8);
}
if ((stringMask & 0x00000200) != 0)
{
(&ev.UserData)[9].DataLength = (uint)(s9.Length < 65535 / 2?s9.Length * 2:65535); //s9.Length * 2;
(&ev.UserData)[9].DataPointer = (void *)(vptr9);
}
ev.BufferSize = 48 + (argCount + 1) * 16; //the extra mof field is for the header
status = EtwTrace.TraceEvent(traceHandle, (char *)&ev);
}
return(status);
}
//TODO[1]: Need to accomodate Win64 alignment issues. Code that might cause problems
// have been tagged with "WIN64 Changes".
private unsafe string EncodeObject(object data, MofField *mofField, char *ptr, ref uint offSet, byte *ptrArgInfo)
{
if (data == null)
{
*ptrArgInfo = (byte)0; //NULL type, WIN64 Changes
*(ushort *)(ptrArgInfo + 1) = (ushort)0;
mofField->DataLength = 0;
mofField->DataPointer = (void *)null; //WIN64 Changes (?)
return(null);
}
string sRet = data as string;
if (sRet != null)
{
*ptrArgInfo = (byte)2; //WIN64 Changes
*(ushort *)(ptrArgInfo + 1) = (ushort)(sRet.Length < 65535?sRet.Length:65535); //WIN64 Changes
return(sRet);
}
if (data is sbyte)
{
mofField->DataLength = sizeof(sbyte);
* ptrArgInfo = (byte)3; //WIN64 Changes
sbyte *sbyteptr = (sbyte *)ptr;
* sbyteptr = (sbyte)data; //WIN64 Changes
mofField->DataPointer = (void *)sbyteptr;
offSet += sizeof(sbyte);
}
else if (data is byte)
{
mofField->DataLength = sizeof(byte);
* ptrArgInfo = (byte)4; //WIN64 Changes
byte *byteptr = (byte *)ptr;
* byteptr = (byte)data; //WIN64 Changes
mofField->DataPointer = (void *)byteptr;
offSet += sizeof(byte);
}
else if (data is short)
{
mofField->DataLength = sizeof(short);
* ptrArgInfo = (byte)5; //WIN64 Changes
short *shortptr = (short *)ptr;
* shortptr = (short)data; //WIN64 Changes
mofField->DataPointer = (void *)shortptr;
offSet += sizeof(short);
}
else if (data is ushort)
{
mofField->DataLength = sizeof(ushort);
* ptrArgInfo = (byte)6; //WIN64 Changes
ushort *ushortptr = (ushort *)ptr;
* ushortptr = (ushort)data; //WIN64 Changes
mofField->DataPointer = (void *)ushortptr;
offSet += sizeof(ushort);
}
else if (data is int)
{
mofField->DataLength = sizeof(int);
* ptrArgInfo = (byte)7; //WIN64 Changes
int *intptr = (int *)ptr;
* intptr = (int)data; //WIN64 Changes
mofField->DataPointer = (void *)intptr;
offSet += sizeof(int);
}
else if (data is uint)
{
mofField->DataLength = sizeof(uint);
* ptrArgInfo = (byte)8; //WIN64 Changes
uint *uintptr = (uint *)ptr;
* uintptr = (uint)data; //WIN64 Changes
mofField->DataPointer = (void *)uintptr;
offSet += sizeof(uint);
}
else if (data is long)
{
mofField->DataLength = sizeof(long);
* ptrArgInfo = (byte)9; //WIN64 Changes
long *longptr = (long *)ptr;
* longptr = (long)data; //WIN64 Changes
mofField->DataPointer = (void *)longptr;
offSet += sizeof(long);
}
else if (data is ulong)
{
mofField->DataLength = sizeof(ulong);
* ptrArgInfo = (byte)10; //WIN64 Changes
ulong *ulongptr = (ulong *)ptr;
* ulongptr = (ulong)data; //WIN64 Changes
mofField->DataPointer = (void *)ulongptr;
offSet += sizeof(ulong);
}
else if (data is char)
{
mofField->DataLength = sizeof(char);
* ptrArgInfo = (byte)11; //WIN64 Changes
char *charptr = (char *)ptr;
* charptr = (char)data; //WIN64 Changes
mofField->DataPointer = (void *)charptr;
offSet += sizeof(char);
}
else if (data is float)
{
mofField->DataLength = sizeof(float);
* ptrArgInfo = (byte)12; //WIN64 Changes
float *floatptr = (float *)ptr;
* floatptr = (float)data; //WIN64 Changes
mofField->DataPointer = (void *)floatptr;
offSet += sizeof(float);
}
else if (data is double)
{
mofField->DataLength = sizeof(double);
* ptrArgInfo = (byte)13; //WIN64 Changes
double *doubleptr = (double *)ptr;
* doubleptr = (double)data; //WIN64 Changes
mofField->DataPointer = (void *)doubleptr;
offSet += sizeof(double);
}
else if (data is bool)
{
mofField->DataLength = sizeof(bool);
* ptrArgInfo = (byte)14; //WIN64 Changes
bool *boolptr = (bool *)ptr;
* boolptr = (bool)data; //WIN64 Changes
mofField->DataPointer = (void *)boolptr;
offSet += sizeof(bool);
}
else if (data is decimal)
{
mofField->DataLength = (uint)sizeof(decimal);
* ptrArgInfo = (byte)15; //WIN64 Changes
decimal *decimalptr = (decimal *)ptr;
* decimalptr = (decimal)data; //WIN64 Changes
mofField->DataPointer = (void *)decimalptr;
offSet += (uint)sizeof(decimal);
}
else
{
//To our eyes, everything else is a just a string
sRet = data.ToString();
*ptrArgInfo = (byte)2; //WIN64 Changes
*(ushort *)(ptrArgInfo + 1) = (ushort)(sRet.Length < 65535?sRet.Length:65535); //WIN64 Changes
return(sRet);
}
*(ushort *)(ptrArgInfo + 1) = (ushort)(mofField->DataLength); //WIN64 Changes (?)
return(sRet);
}
public unsafe uint TraceEvent(Guid eventGuid, uint evtype, object data0, object data1, object data2, object data3, object data4, object data5, object data6, object data7, object data8)
{
uint status = 0;
BaseEvent ev; // Takes up 192 bytes on the stack
char * buffer = stackalloc char[128];
uint offset = 0;
char * ptr = buffer;
string s0, s1, s2, s3, s4, s5, s6, s7, s8;
int stringMask = 0;
uint argCount = 0;
s0 = s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = defaultString;
ev.Flags = 0x00120000; // define Constants
ev.Guid = eventGuid;
ev.ProviderId = evtype;
MofField *be = null;
if (data0 != null)
{
argCount++;
be = &(&ev.UserData)[0];
if ((s0 = ProcessOneObject(data0, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000001;
}
}
if (data1 != null)
{
argCount++;
be = &(&ev.UserData)[1];
ptr = buffer + offset;
if ((s1 = ProcessOneObject(data1, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000002;
}
}
if (data2 != null)
{
argCount++;
be = &(&ev.UserData)[2];
ptr = buffer + offset;
if ((s2 = ProcessOneObject(data2, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000004;
}
}
if (data3 != null)
{
argCount++;
be = &(&ev.UserData)[3];
ptr = buffer + offset;
if ((s3 = ProcessOneObject(data3, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000008;
}
}
if (data4 != null)
{
argCount++;
be = &(&ev.UserData)[4];
ptr = buffer + offset;
if ((s4 = ProcessOneObject(data4, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000010;
}
}
if (data5 != null)
{
argCount++;
be = &(&ev.UserData)[5];
ptr = buffer + offset;
if ((s5 = ProcessOneObject(data5, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000020;
}
}
if (data6 != null)
{
argCount++;
be = &(&ev.UserData)[6];
ptr = buffer + offset;
if ((s6 = ProcessOneObject(data6, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000040;
}
}
if (data7 != null)
{
argCount++;
be = &(&ev.UserData)[7];
ptr = buffer + offset;
if ((s7 = ProcessOneObject(data7, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000080;
}
}
if (data8 != null)
{
argCount++;
be = &(&ev.UserData)[8];
ptr = buffer + offset;
if ((s8 = ProcessOneObject(data8, be, ptr, ref offset)) != null)
{
stringMask |= 0x00000100;
}
}
//
// Now pin all the strings and use the stringMask to pass them over through
// mofField.
//
fixed(char *vptr0 = s0, vptr1 = s1, vptr2 = s2, vptr3 = s3, vptr4 = s4, vptr5 = s5, vptr6 = s6, vptr7 = s7, vptr8 = s8)
{
if ((stringMask & 0x00000001) != 0)
{
(&ev.UserData)[0].DataLength = (uint)s0.Length * 2;
(&ev.UserData)[0].DataPointer = (void *)vptr0;
}
if ((stringMask & 0x00000002) != 0)
{
(&ev.UserData)[1].DataLength = (uint)s1.Length * 2;
(&ev.UserData)[1].DataPointer = (void *)vptr1;
}
if ((stringMask & 0x00000004) != 0)
{
(&ev.UserData)[2].DataLength = (uint)s2.Length * 2;
(&ev.UserData)[2].DataPointer = (void *)vptr2;
}
if ((stringMask & 0x00000008) != 0)
{
(&ev.UserData)[3].DataLength = (uint)s3.Length * 2;
(&ev.UserData)[3].DataPointer = (void *)vptr3;
}
if ((stringMask & 0x00000010) != 0)
{
(&ev.UserData)[4].DataLength = (uint)s4.Length * 2;
(&ev.UserData)[4].DataPointer = (void *)vptr4;
}
if ((stringMask & 0x00000020) != 0)
{
(&ev.UserData)[5].DataLength = (uint)s5.Length * 2;
(&ev.UserData)[5].DataPointer = (void *)vptr5;
}
if ((stringMask & 0x00000040) != 0)
{
(&ev.UserData)[6].DataLength = (uint)s6.Length * 2;
(&ev.UserData)[6].DataPointer = (void *)vptr6;
}
if ((stringMask & 0x00000080) != 0)
{
(&ev.UserData)[7].DataLength = (uint)s7.Length * 2;
(&ev.UserData)[7].DataPointer = (void *)vptr7;
}
if ((stringMask & 0x00000100) != 0)
{
(&ev.UserData)[8].DataLength = (uint)s8.Length * 2;
(&ev.UserData)[8].DataPointer = (void *)vptr8;
}
ev.BufferSize = 48 + argCount * 16;
status = EtwTrace.TraceEvent(traceHandle, (char *)&ev);
}
return(status);
}
