lttng.py

#-------------------------------------------------------------------------------------------------------
# Copyright (C) Microsoft. All rights reserved.
# Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
#-------------------------------------------------------------------------------------------------------
import xml.dom.minidom as DOM

lttngDataTypeMapping = {
    "win:null"          :" ",
    "win:Int64"         :"const __int64",
    "win:ULong"         :"const unsigned long",
    "win:count"         :"*",
    "win:Struct"        :"const char *",
    "win:GUID"          :"const int",
    "win:AnsiString"    :"const char*",
    "win:UnicodeString" :"const char*",
    "win:Double"        :"const double",
    "win:Int32"         :"const signed int",
    "win:HexInt32"      :"const signed int",
    "win:Boolean"       :"const bool",
    "win:UInt64"        :"const unsigned __int64",
    "win:UInt32"        :"const unsigned int",
    "win:UInt16"        :"const unsigned short",
    "win:UInt8"         :"const unsigned char",
    "win:Int8"          :"const char",
    "win:Pointer"       :"const uintptr_t",
    "win:Binary"        :"const char"
}

ctfDataTypeMapping = {
    "win:Int64"         :"ctf_integer",
    "win:HexInt64"      :"ctf_integer_hex",
    "win:ULong"         :"ctf_integer",
    "win:count"         :"ctf_sequence",
    "win:Struct"        :"ctf_sequence",
    "win:GUID"          :"ctf_sequence",
    "win:AnsiString"    :"ctf_string",
    "win:UnicodeString" :"ctf_string",
    "win:Double"        :"ctf_float",
    "win:Int32"         :"ctf_integer",
    "win:HexInt32"      :"ctf_integer_hex",
    "win:Boolean"       :"ctf_integer",
    "win:UInt64"        :"ctf_integer",
    "win:UInt32"        :"ctf_integer",
    "win:UInt16"        :"ctf_integer",
    "win:HexInt16"      :"ctf_integer_hex",
    "win:UInt8"         :"ctf_integer",  #actually a character
    "win:Int8"          :"ctf_integer",  #actually a character
    "win:Pointer"       :"ctf_integer",
    "win:Binary"        :"ctf_sequence",
    "xs:string"         :"ctf_string",
    "xs:unsignedLong"   :"ctf_integer",
    "xs:unsignedInt"    :"ctf_integer"
}

palDataTypeMapping ={
        "win:null"          :" ",
        "win:Int64"         :"const __int64",
        "win:ULong"         :"const unsigned long",
        "win:count"         :"*",
        "win:Struct"        :"const void",
        "win:GUID"          :"const GUID",
        "win:AnsiString"    :"LPCSTR",
        "win:UnicodeString" :"PCWSTR",
        "win:Double"        :"const double",
        "win:Int32"         :"const signed int",
        "win:HexInt32"      :"const signed int",
        "win:Boolean"       :"const bool",
        "win:UInt64"        :"const unsigned __int64",
        "win:UInt32"        :"const unsigned int",
        "win:UInt16"        :"const unsigned short",
        "win:UInt8"         :"const unsigned char",
        "win:Int8"          :"const char",
        "win:Pointer"       :"const void*",
        "win:Binary"        :"const char"
        }

MAX_LTTNG_ARGS = 10

def getParamSequenceSize(paramSequence, estimate):
    total = 0
    pointers =0
    for param in paramSequence:
        if param in ["win:Int64", "win:UInt64", "win:Double"]:
            total += 8
        elif param in ["win:ULong", "win:Int32", "win:Boolean",]:
            total += 4
        elif param == "GUID":
            total += 16
        elif param in ["win:UInt16"]:
            total += 2
        elif param in ["win:Uint8", "win:Binary"]:
            total += 1
        elif param == "win:Pointer":
            if estimate:
                total += 8
            else:
                pointers += 1
        elif estimate:
            if param in ["win:AnsiString", "win:Struct"]:
                total += 32
            elif param in ["win:UnicodeString"]:
                total += 64
        else:
            raise Exception ("Don't know size of " + param)

    if estimate:
        return total

    return total, pointers

class Template:
    def __repr__(self):
        return "<Template " + self.name + " />"
    
    def __init__(self, name, prototypes, dependencies, structCounts, arrayCounts):
        self.name = name
        self.signature = FunctionSignature()
        self.structCounts = structCounts
        self.arrayCounts = arrayCounts

        for variable in prototypes.paramList:
            for dependency in dependencies[variable]:
                if not self.signature.getParam(dependency):
                    self.signature.append(dependency, prototypes.getParam(dependency))
    @property
    def num_params(self):
        return len(self.signature.paramList)

    def getParam(self, name):
        return self.signature.getParam(name)

    @property
    def estimatedSize(self):
        total = getParamSequenceSize((self.getParam(paramName).winType for paramName in self.signature.paramList), True)

        if total < 32:
            return 32
        elif total > 1024:
            return 1024
        return total

class FunctionSignature:
    def __repr__(self):
        return ', '.join(self.paramList)
        
    def __init__(self):
        self.LUT = {}
        self.paramList = []

    def append(self, variable, param):
        self.LUT[variable] = param
        self.paramList.append(variable)

    def getParam(self, variable):
        return self.LUT.get(variable)

    def getLength(self):
        return len(self.paramList)

class FunctionParameter:
    def __repr__(self):
        return self.name

    def __init__(self, winType, name, count, outType, length):
        self.winType = winType
        self.outType = outType
        self.name = name
        self.length = length
        self.count = "win:null"
        if winType == "win:GUID" or count == "win:count":
            self.count = "win:count"

ignoredXmlAttributes = frozenset(["map"])
usedXmlAttributes    = frozenset(["name", "inType", "count", "length", "outType"])
knownXmlAttributes   = ignoredXmlAttributes | usedXmlAttributes
            
def checkKnownAttributes(nodes, templateName):
    for node in nodes:
        nodeMap = node.attributes
        for attribute in nodeMap.values():
            if attribute.name not in knownXmlAttributes:
                raise ValueError('Unknown attribute: ' + attribute.name + ' in template ' + templateName)

def getTopLevelElementsByTagName(node, tag):
    return [e for e in node.getElementsByTagName(tag) if e.parentNode == node]
            
def parseTemplateNodes(templateNodes):
    templates = {}

    for templateNode in templateNodes:
        templateName = templateNode.getAttribute('tid')
        dataNodes = getTopLevelElementsByTagName(templateNode, 'data')

        checkKnownAttributes(dataNodes, templateName)

        functionPrototypes = FunctionSignature()
        
        arrayCounts = {}
        structCounts = {}
        var_Dependencies = {}

        for dataNode in dataNodes:
            variable = dataNode.getAttribute('name')
            wintype = dataNode.getAttribute('inType')
            outType = dataNode.getAttribute('outType')

            wincount = dataNode.getAttribute('count')
            winLength = dataNode.getAttribute('length')

            var_dependency = [variable]
            if winLength:
                if wincount:
                    raise Exception("Both count and length properties found on " + variable + " in template " + templateName)

            if wincount.isdigit() and int(wincount) == 1:
                wincount = ''

            if wincount:
                if wincount.isdigit():
                    raise Exception("Expect constant count to be length")
                elif functionPrototypes.getParam(wincount):
                    var_dependency.insert(0, wincount)
                    arrayCounts[variable] = wincount


            var_Dependencies[variable] = var_dependency
            functionParameter = FunctionParameter(wintype, variable, wincount, outType, winLength)
            functionPrototypes.append(variable, functionParameter)

        structNodes = getTopLevelElementsByTagName(templateNode, 'struct')

        for structNode in structNodes:
            structName = structNode.getAttribute('name')
            countName  = structNode.getAttribute('count')

            assert(countName in functionPrototypes.paramList)

            #childData = structNode.getElementsByTagName("data")
            #names = [x.attributes['name'].value for x in childData]
            #types = [x.attributes['inType'].value for x in childData]

            structCounts[structName] = countName
            var_Dependencies[structName] = [countName, structName]
            functionParameterPointer = FunctionParameter("win:Struct", structName, "win:count", None, None)
            functionPrototypes.append(structName, functionParameterPointer)

        templates[templateName] = Template(templateName, functionPrototypes, var_Dependencies, structCounts, arrayCounts)

    return templates
            
def shouldPackTemplate(template):
    return template.num_params > MAX_LTTNG_ARGS or len(template.structCounts) > 0 or len(template.arrayCounts) > 0

def generateArgList(template):
    # Construct a TP_ARGS macro call, as defined in another macro, e.g.
    #
    # TP_ARGS(                \
    #    int, my_integer_arg, \
    #    char*, my_string_arg \
    # )
    header = "TP_ARGS( \\\n"
    footer = "\\\n)"

    args = []

    if shouldPackTemplate(template):
        args.append("        const unsigned int, length")
        args.append("        const char *, __data__")
    else:
        signature = template.signature
        for param in signature.paramList:
            functionParam = signature.getParam(param)
            wintypeName   = functionParam.winType
            mappedType    = lttngDataTypeMapping[wintypeName]
            winCount      = functionParam.count
            mappedCount   = lttngDataTypeMapping[winCount]

            arg = "        " + mappedType
            if mappedCount != " ":
                arg += mappedCount
            elif functionParam.length:
                arg += "*"
            arg += ", " + functionParam.name
            
            args.append(arg)
        
    return header + ", \\\n".join(args) + footer

def generateFieldList(template):
    # Construct a TP_FIELDS macro call, e.g.
    # TP_FIELDS(
    #     ctf_string(my_string_field, my_string_arg)
    #     ctf_integer(int, my_integer_field, my_integer_arg)
    # )
    header = "    " + " TP_FIELDS(\n"
    footer = "\n    )"

    fieldList = []
    
    if shouldPackTemplate(template):
        fieldList.append("      ctf_integer(unsigned long, length, length)")
        fieldList.append("      ctf_sequence(char, __data__, __data__, unsigned long, length)")
    else:
        signature = template.signature
        for param in signature.paramList:
            functionParam = signature.getParam(param)
            wintypeName   = functionParam.winType
            winCount      = functionParam.count
            mappedCount   = lttngDataTypeMapping[winCount]
            mappedType    = lttngDataTypeMapping[wintypeName].replace("const ", "")

            if functionParam.outType:
                wintypeName = functionParam.outType

            ctf_type = None
            field_body = None
            varname = functionParam.name

            if param in template.structCounts or param in template.arrayCounts:
                # This is a struct, treat as a sequence
                countVar = template.structCounts.get(param, template.arrayCounts.get(param))
                ctf_type = "ctf_sequence"
                field_body = ", ".join((mappedType, varname, varname, "size_t", functionParam.prop))
            elif functionParam.length:
                ctf_type = "ctf_sequence"
                field_body = ", ".join((mappedType, varname, varname, "size_t", functionParam.length))
            else:
                ctf_type = ctfDataTypeMapping[wintypeName]
                if ctf_type == "ctf_string":
                    field_body = ", ".join((varname, varname))
                elif ctf_type == "ctf_integer" or ctf_type == "ctf_integer_hex" or ctf_type == "ctf_float":
                    field_body = ", ".join((mappedType, varname, varname))
                elif ctf_type == "ctf_sequence":
                    raise Exception("ctf_sequence needs special handling: " + template.name + " " + param)
                else:
                    raise Exception("Unhandled ctf intrinsic: " + ctf_type)

#            fieldList.append("//    " + wintypeName)
            fieldList.append("      %s(%s)" % (ctf_type, field_body))
    
    return header + "\n".join(fieldList) + footer

def generateLttngHeader(providerName, lttngEventHeaderShortName, templates, events):
    headerLines = []

    headerLines.append("")
    headerLines.append("#ifdef __int64")
    headerLines.append("#if TARGET_64")
    headerLines.append("#undef __int64")
    headerLines.append("#else")
    headerLines.append("#error \"Linux and OSX builds only support 64bit platforms\"")
    headerLines.append("#endif // TARGET_64")
    headerLines.append("#endif // __int64")
    headerLines.append("#undef TRACEPOINT_PROVIDER")
    headerLines.append("#undef TRACEPOINT_INCLUDE")
    headerLines.append("")
    headerLines.append("#define TRACEPOINT_PROVIDER " + providerName + "\n")
    headerLines.append("#define TRACEPOINT_INCLUDE \"./" + lttngEventHeaderShortName + "\"\n\n")

    headerLines.append("#if !defined(LTTNG_CHAKRA_H" + providerName + ") || defined(TRACEPOINT_HEADER_MULTI_READ)\n\n")
    headerLines.append("#define LTTNG_CHAKRA_H" + providerName +"\n")

    headerLines.append("\n#include <lttng/tracepoint.h>\n\n")

    
    for templateName in templates:
        template = templates[templateName]
        functionSignature = template.signature

        headerLines.append("")
        headerLines.append("#define " + templateName + "_TRACEPOINT_ARGS \\")

        tracepointArgs = generateArgList(template)
        headerLines.append(tracepointArgs)

        headerLines.append("TRACEPOINT_EVENT_CLASS(")
        headerLines.append("    " + providerName + ",")
        headerLines.append("    " + templateName + ",")
        headerLines.append("    " + templateName + "_TRACEPOINT_ARGS,")
        tracepointFields = generateFieldList(template)
        headerLines.append(tracepointFields)
        headerLines.append(")")
                        
        headerLines.append("#define " + templateName + "T_TRACEPOINT_INSTANCE(name) \\")
        headerLines.append("TRACEPOINT_EVENT_INSTANCE(\\")
        headerLines.append("    " + providerName + ",\\")
        headerLines.append("    " + templateName + ",\\")
        headerLines.append("    name,\\")
        headerLines.append("    " + templateName + "_TRACEPOINT_ARGS \\")
        headerLines.append(")")

    headerLines.append("")
    headerLines.append("")
    headerLines.append("TRACEPOINT_EVENT_CLASS(")
    headerLines.append("    " + providerName + ",")
    headerLines.append("    emptyTemplate,")
    headerLines.append("    TP_ARGS(),")
    headerLines.append("    TP_FIELDS()")
    headerLines.append(")")
    headerLines.append("#define T_TRACEPOINT_INSTANCE(name) \\")
    headerLines.append("TRACEPOINT_EVENT_INSTANCE(\\")
    headerLines.append("    " + providerName + ",\\")
    headerLines.append("    emptyTemplate,\\")
    headerLines.append("    name,\\")
    headerLines.append("    TP_ARGS()\\")
    headerLines.append(")")

    headerLines.append("")

    for eventNode in events:
        eventName    = eventNode.getAttribute('symbol')
        templateName = eventNode.getAttribute('template')

        if not eventName:
            raise Exception(eventNode + " event does not have a symbol")
        if not templateName:
            headerLines.append("T_TRACEPOINT_INSTANCE(" + eventName + ")")
            continue

        headerLines.append(templateName + "T_TRACEPOINT_INSTANCE(" + eventName + ")")

    headerLines.append("#endif /* LTTNG_CHAKRA_H" + providerName + " */")
    headerLines.append("#include <lttng/tracepoint-event.h>")

    return "\n".join(headerLines)

def generateMethodBody(template, providerName, eventName):
    # Convert from ETW's windows types to LTTng compatiable types

    methodBody = [""]
    
    functionSignature = template.signature

    if not shouldPackTemplate(template):
        invocation = ["do_tracepoint(" + providerName, eventName]

        for paramName in functionSignature.paramList:
            functionParam = functionSignature.getParam(paramName)
            wintypeName   = functionParam.winType
            winCount      = functionParam.count
            
            ctf_type      = None

            if functionParam.outType:
                ctf_type = ctfDataTypeMapping.get(functionParam.outType)
            else:
                ctf_Type = ctfDataTypeMapping.get(winCount)

            if not ctf_type:
                ctf_type = ctfDataTypeMapping[wintypeName]

            if ctf_type == "ctf_string" and wintypeName == "win:UnicodeString":
                # Convert wchar unicode string to utf8
                if functionParam.length:
                    methodBody.append("utf8::WideToNarrow " + paramName + "_converter(" + paramName + ", " + functionParam.length + ");")
                else:
                    methodBody.append("utf8::WideToNarrow " + paramName + "_converter(" + paramName + ");")
                invocation.append(paramName + "_converter")
#            elif ctf_type == "ctf_sequence" or wintypeName == "win:Pointer":
            elif wintypeName == "win:Pointer":
                invocation.append("(" + lttngDataTypeMapping[wintypeName] + lttngDataTypeMapping[winCount] + ")" + paramName)
            else:
                invocation.append(paramName)

        methodBody.append(",\n        ".join(invocation) + ");")
    else:
        # Packing results into buffer
        methodBody.append("char stackBuffer[" + str(template.estimatedSize) + "];")
        methodBody.append("char *buffer = stackBuffer;")
        methodBody.append("int offset = 0;")
        methodBody.append("int size = " + str(template.estimatedSize) + ";")
        methodBody.append("bool fixedBuffer = true;")
        methodBody.append("bool success = true;")

        for paramName in functionSignature.paramList:
            functionParameter = functionSignature.getParam(paramName)

            if paramName in template.structCounts:
                size = "(unsigned int)" + paramName + "_ElementSize * (unsigned int)" + template.structCounts[paramName]
                methodBody.append("success &= WriteToBuffer((const char *)" + paramName + ", " + size + ", buffer, offset, size, fixedBuffer);")
            elif paramName in template.arrayCounts:
                size = "sizeof(" + lttngDataTypeMapping[functionParameter.winType] + ") * (unsigned int)" + template.arrayCounts[paramName]
                methodBody.append("success &= WriteToBuffer((const char *)" + paramName + ", " + size + ", buffer, offset, size, fixedBuffer);")
            elif functionParameter.winType == "win:GUID":
                methodBody.append("success &= WriteToBuffer(*" + paramName + ", buffer, offset, size, fixedBuffer);")
            else:
                methodBody.append("success &= WriteToBuffer(" + paramName + ", buffer, offset, size, fixedBuffer);")

        methodBody.append("if (!success)")
        methodBody.append("{")
        methodBody.append("    if (!fixedBuffer) delete[] buffer;")
        methodBody.append("    return ERROR_WRITE_FAULT;")
        methodBody.append("}")
        methodBody.append("do_tracepoint(" + providerName + ", " + eventName + ", offset, buffer);")
        methodBody.append("if (!fixedBuffer) delete[] buffer;")

    return "\n    ".join(methodBody) + "\n"

def generateMethodSignature(template):
    if not template:
        return ""
    
    functionSignature = template.signature
    lineFunctionPrototype = []
    for paramName in functionSignature.paramList:
        functionParameter = functionSignature.getParam(paramName)
        wintypeName = functionParameter.winType
        mappedType = palDataTypeMapping[wintypeName]
        winCount = functionParameter.count
        mappedCount = palDataTypeMapping[winCount]

        if paramName in template.structCounts:
            lineFunctionPrototype.append("    int " + paramName + "_ElementSize")
        # lineFunctionPrototype.append("//    " + wintypeName + " " + str(functionParameter.length))
        lineFunctionPrototype.append(
            "    " + mappedType
            + (mappedCount if mappedCount != " " else "*" if functionParameter.length and not wintypeName in ["win:UnicodeString", "win:AnsiString"] else "")
            + " "
            + functionParameter.name)
    return ",\n".join(lineFunctionPrototype)


def generateLttngTracepointProvider(providerName, lttngHeader, templates, events):
    providerLines = [];

    providerLines.append("#define TRACEPOINT_DEFINE")
    providerLines.append("#ifndef CHAKRA_STATIC_LIBRARY")
    providerLines.append("#define TRACEPOINT_PROBE_DYNAMIC_LINKAGE")
    providerLines.append("#endif")
    providerLines.append("#include \"stdlib.h\"")
    providerLines.append("#include \"Common.h\"")
    providerLines.append("#include \"Codex/Utf8Helper.h\"")
    
    providerLines.append("#include \"" + lttngHeader + "\"\n\n")
    providerLines.append("#ifndef tracepoint_enabled")
    providerLines.append("#define tracepoint_enabled(provider, name) 1")
    providerLines.append("#define do_tracepoint tracepoint")
    providerLines.append("#endif")

    providerLines.append("""
bool ResizeBuffer(char *&buffer, int&size, int currentLength, int newSize, bool &fixedBuffer)
{
    newSize *= 1.5;
    _ASSERTE(newSize > size); // Check for overflow

    if (newSize < 32)
    {
        newSize = 32;
    }

    char *newBuffer = new char[newSize];
    memcpy(newBuffer, buffer, currentLength);

    if (!fixedBuffer)
    {
        delete[] buffer;
    }

    buffer = newBuffer;
    size = newSize;
    fixedBuffer = false;
    return true;
}

bool WriteToBuffer(const char * src, int len, char *&buffer, int &offset, int &size, bool &fixedBuffer)
{
    if (!src)
    {
        return true;
    }
    if (offset + len > size)
    {
        if (!ResizeBuffer(buffer, size, offset, size+len, fixedBuffer))
        {
            return false;
        }
    }

    memcpy(buffer + offset, src, len);
    offset += len;
    return true;
}

template <typename T>
bool WriteToBuffer(const T &value, char *&buffer, int&offset, int&size, bool &fixedBuffer)
{
    if (sizeof(T) + offset > size)
    {
        if (!ResizeBuffer(buffer, size, offset, size + sizeof(T), fixedBuffer))
        {
            return false;
        }
    }

    *(T *)(buffer + offset) = value;
    offset += sizeof(T);
    return true;
}
""")

    for eventNode in events:
        eventName    = eventNode.getAttribute('symbol')
        templateName = eventNode.getAttribute('template')

        providerLines.append("extern \"C\" bool EventXplatEnabled%s(){ return tracepoint_enabled(%s, %s);}"
                             % (eventName, providerName, eventName))
        providerLines.append("")

        template = None
        if templateName:
            template = templates[templateName]

        providerLines.append("extern \"C\" unsigned long FireEtXplat" + eventName + "(")
        providerLines.append(generateMethodSignature(template))
        providerLines.append(")")
        providerLines.append("{")
        providerLines.append("    if (!EventXplatEnabled" + eventName + "())")
        providerLines.append("        return ERROR_SUCCESS;")

        if template:
            providerLines.append(generateMethodBody(template, providerName, eventName))
        else:
            providerLines.append("    do_tracepoint(" + providerName + ", " + eventName +");")

        providerLines.append("")
        providerLines.append("    return ERROR_SUCCESS;")
        providerLines.append("}")
        providerLines.append("")

    return "\n".join(providerLines)

def generateEtwHeader(templates, events):
    headerLines = []

    headerLines.append("#include \"pal.h\"")
    headerLines.append("")
    
    for event in events:
        eventName = event.getAttribute('symbol')
        templateName = event.getAttribute('template')

        template = None
        if templateName:
            template = templates[templateName]

        callArgs = []
        if template:
            functionSignature = template.signature
            for param in functionSignature.paramList:
                if param in template.structCounts:
                    callArgs.append(param + "_ElementSize")
                callArgs.append(param)

        headerLines.append("extern \"C\" bool EventXplatEnabled" + eventName +"();")
        headerLines.append("inline bool EventEnabled" + eventName +"() { return EventXplatEnabled" + eventName + "();}")
        headerLines.append("")
        headerLines.append("extern \"C\" unsigned long FireEtXplat" + eventName +" (")
        headerLines.append(generateMethodSignature(template))
        headerLines.append(");")
        headerLines.append("inline unsigned long EventWrite" + eventName + "(")
        headerLines.append(generateMethodSignature(template))
        headerLines.append(")")
        headerLines.append("{")
        headerLines.append("    return FireEtXplat" + eventName + "(" + ", ".join(callArgs) + ");")
        headerLines.append("}")
        headerLines.append("")
        

    return "\n".join(headerLines)

def generateCmakeFile(providerName):
    cmakeLines = []
    cmakeLines.append("project(Chakra.LTTng)")
    cmakeLines.append("")
    cmakeLines.append("add_compile_options(-fPIC)")
    cmakeLines.append("")
    cmakeLines.append("add_library (Chakra.LTTng OBJECT")
    cmakeLines.append("  eventprovider" + providerName + ".cpp")
    cmakeLines.append("  tracepointprovider" + providerName + ".cpp")
    cmakeLines.append(")")

    return "\n".join(cmakeLines)

def generateLttngFiles(manifest, providerDirectory):
    import os
    tree = DOM.parse(manifest)

    if not os.path.exists(providerDirectory):
        os.makedirs(providerDirectory)

    if not os.path.exists(providerDirectory + "/lttng"):
        os.makedirs(providerDirectory + "/lttng")

    for providerNode in tree.getElementsByTagName("provider"):
        providerName = providerNode.getAttribute("name")
        providerName = providerName.replace("Microsoft-", "")

        providerNameFile = providerName.lower()

        lttngEventHeaderShortName = "tp" + providerNameFile + ".h"
        lttngEventHeaderPath      = providerDirectory + "/lttng/" + lttngEventHeaderShortName
        lttngEventProvider        = providerDirectory + "/lttng/eventprovider" + providerNameFile + ".cpp"
        lttngEventProviderTrace   = providerDirectory + "/lttng/tracepointprovider" + providerNameFile + ".cpp"
        lttngEtwHeaderFile        = providerDirectory + "/lttng/" + providerNameFile + "Etw.h"
        lttngCmakeFile            = providerDirectory + "/lttng/CMakeLists.txt"

        lttngHeader              = open(lttngEventHeaderPath, "w")
        lttngImplementation      = open(lttngEventProvider, "w")
        lttngTraceImplementation = open(lttngEventProviderTrace, "w")
        lttngEtwHeader           = open(lttngEtwHeaderFile, "w")
        lttngCmake               = open(lttngCmakeFile, "w")

        # Create the lttng implementation
        lttngTraceImplementation.write("#define TRACEPOINT_CREATE_PROBES\n")
        lttngTraceImplementation.write("#include \"./"+lttngEventHeaderShortName+"\"\n")
        lttngTraceImplementation.close()

        # Create the lttng header

        templateNodes = providerNode.getElementsByTagName('template')
        eventNodes = providerNode.getElementsByTagName('event')

        allTemplates = parseTemplateNodes(templateNodes)

        lttngHeader.write(generateLttngHeader(providerName, lttngEventHeaderShortName, allTemplates, eventNodes))
        lttngHeader.close();

        lttngImplementation.write(generateLttngTracepointProvider(providerName, lttngEventHeaderShortName, allTemplates, eventNodes))
        lttngImplementation.close();

        lttngEtwHeader.write(generateEtwHeader(allTemplates, eventNodes))
        lttngEtwHeader.close()

        # Note: This in particular assumes that there is only one ETW provider
        lttngCmake.write(generateCmakeFile(providerNameFile))
        lttngCmake.close()

if __name__ == '__main__':
    import argparse
    import sys

    parser = argparse.ArgumentParser(description="Generates the Code required to instrument LTTtng logging mechanism")

    required = parser.add_argument_group('required arguments')
    required.add_argument('--man',  type=str, required=True,
                                    help='full path to manifest containig the description of events')
    required.add_argument('--intermediate', type=str, required=True,
                                    help='full path to eventprovider intermediate directory')
    args, unknown = parser.parse_known_args(sys.argv[1:])
    if unknown:
        print('Unknown argument(s): ', ', '.join(unknown))
        sys.exit(1)

    generateLttngFiles(args.man, args.intermediate)
    sys.exit(0)