@@ -1,7 +1,7 @@

 # the following lines are in sorted order, FYI

 github.com/Azure/go-ansiterm d6e3b3328b783f23731bc4d058875b0371ff8109

 github.com/Microsoft/hcsshim ada9cb39f715fb568e1030e7613732bb4f1e4aeb

-github.com/Microsoft/go-winio 4de24ed3e8c509e6d1f609a8cb6b1c9fd9816e6d

+github.com/Microsoft/go-winio c599b533b43b1363d7d7c6cfda5ede70ed73ff13

 github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a

 github.com/go-check/check 4ed411733c5785b40214c70bce814c3a3a689609 https://github.com/cpuguy83/check.git

 github.com/golang/gddo 9b12a26f3fbd7397dee4e20939ddca719d840d2a

deleted file mode 100644

@@ -1,15 +0,0 @@

-// Package etw provides support for TraceLogging-based ETW (Event Tracing

-// for Windows). TraceLogging is a format of ETW events that are self-describing

-// (the event contains information on its own schema). This allows them to be

-// decoded without needing a separate manifest with event information. The

-// implementation here is based on the information found in

-// TraceLoggingProvider.h in the Windows SDK, which implements TraceLogging as a

-// set of C macros.

-package etw

-

-//go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go etw.go

-

-//sys eventRegister(providerId *windows.GUID, callback uintptr, callbackContext uintptr, providerHandle *providerHandle) (win32err error) = advapi32.EventRegister

-//sys eventUnregister(providerHandle providerHandle) (win32err error) = advapi32.EventUnregister

-//sys eventWriteTransfer(providerHandle providerHandle, descriptor *EventDescriptor, activityID *windows.GUID, relatedActivityID *windows.GUID, dataDescriptorCount uint32, dataDescriptors *eventDataDescriptor) (win32err error) = advapi32.EventWriteTransfer

-//sys eventSetInformation(providerHandle providerHandle, class eventInfoClass, information uintptr, length uint32) (win32err error) = advapi32.EventSetInformation

deleted file mode 100644

@@ -1,65 +0,0 @@

-package etw

-

-import (

-	"bytes"

-	"encoding/binary"

-)

-

-// EventData maintains a buffer which builds up the data for an ETW event. It

-// needs to be paired with EventMetadata which describes the event.

-type EventData struct {

-	buffer bytes.Buffer

-}

-

-// Bytes returns the raw binary data containing the event data. The returned

-// value is not copied from the internal buffer, so it can be mutated by the

-// EventData object after it is returned.

-func (ed *EventData) Bytes() []byte {

-	return ed.buffer.Bytes()

-}

-

-// WriteString appends a string, including the null terminator, to the buffer.

-func (ed *EventData) WriteString(data string) {

-	ed.buffer.WriteString(data)

-	ed.buffer.WriteByte(0)

-}

-

-// WriteInt8 appends a int8 to the buffer.

-func (ed *EventData) WriteInt8(value int8) {

-	ed.buffer.WriteByte(uint8(value))

-}

-

-// WriteInt16 appends a int16 to the buffer.

-func (ed *EventData) WriteInt16(value int16) {

-	binary.Write(&ed.buffer, binary.LittleEndian, value)

-}

-

-// WriteInt32 appends a int32 to the buffer.

-func (ed *EventData) WriteInt32(value int32) {

-	binary.Write(&ed.buffer, binary.LittleEndian, value)

-}

-

-// WriteInt64 appends a int64 to the buffer.

-func (ed *EventData) WriteInt64(value int64) {

-	binary.Write(&ed.buffer, binary.LittleEndian, value)

-}

-

-// WriteUint8 appends a uint8 to the buffer.

-func (ed *EventData) WriteUint8(value uint8) {

-	ed.buffer.WriteByte(value)

-}

-

-// WriteUint16 appends a uint16 to the buffer.

-func (ed *EventData) WriteUint16(value uint16) {

-	binary.Write(&ed.buffer, binary.LittleEndian, value)

-}

-

-// WriteUint32 appends a uint32 to the buffer.

-func (ed *EventData) WriteUint32(value uint32) {

-	binary.Write(&ed.buffer, binary.LittleEndian, value)

-}

-

-// WriteUint64 appends a uint64 to the buffer.

-func (ed *EventData) WriteUint64(value uint64) {

-	binary.Write(&ed.buffer, binary.LittleEndian, value)

-}

deleted file mode 100644

@@ -1,29 +0,0 @@

-package etw

-

-import (

-	"unsafe"

-)

-

-type eventDataDescriptorType uint8

-

-const (

-	eventDataDescriptorTypeUserData eventDataDescriptorType = iota

-	eventDataDescriptorTypeEventMetadata

-	eventDataDescriptorTypeProviderMetadata

-)

-

-type eventDataDescriptor struct {

-	ptr       ptr64

-	size      uint32

-	dataType  eventDataDescriptorType

-	reserved1 uint8

-	reserved2 uint16

-}

-

-func newEventDataDescriptor(dataType eventDataDescriptorType, buffer []byte) eventDataDescriptor {

-	return eventDataDescriptor{

-		ptr:      ptr64{ptr: unsafe.Pointer(&buffer[0])},

-		size:     uint32(len(buffer)),

-		dataType: dataType,

-	}

-}

deleted file mode 100644

@@ -1,67 +0,0 @@

-package etw

-

-// Channel represents the ETW logging channel that is used. It can be used by

-// event consumers to give an event special treatment.

-type Channel uint8

-

-const (

-	// ChannelTraceLogging is the default channel for TraceLogging events. It is

-	// not required to be used for TraceLogging, but will prevent decoding

-	// issues for these events on older operating systems.

-	ChannelTraceLogging Channel = 11

-)

-

-// Level represents the ETW logging level. There are several predefined levels

-// that are commonly used, but technically anything from 0-255 is allowed.

-// Lower levels indicate more important events, and 0 indicates an event that

-// will always be collected.

-type Level uint8

-

-// Predefined ETW log levels.

-const (

-	LevelAlways Level = iota

-	LevelCritical

-	LevelError

-	LevelWarning

-	LevelInfo

-	LevelVerbose

-)

-

-// EventDescriptor represents various metadata for an ETW event.

-type EventDescriptor struct {

-	id      uint16

-	version uint8

-	Channel Channel

-	Level   Level

-	Opcode  uint8

-	Task    uint16

-	Keyword uint64

-}

-

-// NewEventDescriptor returns an EventDescriptor initialized for use with

-// TraceLogging.

-func NewEventDescriptor() *EventDescriptor {

-	// Standard TraceLogging events default to the TraceLogging channel, and

-	// verbose level.

-	return &EventDescriptor{

-		Channel: ChannelTraceLogging,

-		Level:   LevelVerbose,

-	}

-}

-

-// Identity returns the identity of the event. If the identity is not 0, it

-// should uniquely identify the other event metadata (contained in

-// EventDescriptor, and field metadata). Only the lower 24 bits of this value

-// are relevant.

-func (ed *EventDescriptor) Identity() uint32 {

-	return (uint32(ed.version) << 16) | uint32(ed.id)

-}

-

-// SetIdentity sets the identity of the event. If the identity is not 0, it

-// should uniquely identify the other event metadata (contained in

-// EventDescriptor, and field metadata). Only the lower 24 bits of this value

-// are relevant.

-func (ed *EventDescriptor) SetIdentity(identity uint32) {

-	ed.id = uint16(identity)

-	ed.version = uint8(identity >> 16)

-}

deleted file mode 100644

@@ -1,177 +0,0 @@

-package etw

-

-import (

-	"bytes"

-	"encoding/binary"

-)

-

-// InType indicates the type of data contained in the ETW event.

-type InType byte

-

-// Various InType definitions for TraceLogging. These must match the definitions

-// found in TraceLoggingProvider.h in the Windows SDK.

-const (

-	InTypeNull InType = iota

-	InTypeUnicodeString

-	InTypeANSIString

-	InTypeInt8

-	InTypeUint8

-	InTypeInt16

-	InTypeUint16

-	InTypeInt32

-	InTypeUint32

-	InTypeInt64

-	InTypeUint64

-	InTypeFloat

-	InTypeDouble

-	InTypeBool32

-	InTypeBinary

-	InTypeGUID

-	InTypePointerUnsupported

-	InTypeFileTime

-	InTypeSystemTime

-	InTypeSID

-	InTypeHexInt32

-	InTypeHexInt64

-	InTypeCountedString

-	InTypeCountedANSIString

-	InTypeStruct

-	InTypeCountedBinary

-	InTypeCountedArray InType = 32

-	InTypeArray        InType = 64

-)

-

-// OutType specifies a hint to the event decoder for how the value should be

-// formatted.

-type OutType byte

-

-// Various OutType definitions for TraceLogging. These must match the

-// definitions found in TraceLoggingProvider.h in the Windows SDK.

-const (

-	// OutTypeDefault indicates that the default formatting for the InType will

-	// be used by the event decoder.

-	OutTypeDefault OutType = iota

-	OutTypeNoPrint

-	OutTypeString

-	OutTypeBoolean

-	OutTypeHex

-	OutTypePID

-	OutTypeTID

-	OutTypePort

-	OutTypeIPv4

-	OutTypeIPv6

-	OutTypeSocketAddress

-	OutTypeXML

-	OutTypeJSON

-	OutTypeWin32Error

-	OutTypeNTStatus

-	OutTypeHResult

-	OutTypeFileTime

-	OutTypeSigned

-	OutTypeUnsigned

-	OutTypeUTF8              OutType = 35

-	OutTypePKCS7WithTypeInfo OutType = 36

-	OutTypeCodePointer       OutType = 37

-	OutTypeDateTimeUTC       OutType = 38

-)

-

-// EventMetadata maintains a buffer which builds up the metadata for an ETW

-// event. It needs to be paired with EventData which describes the event.

-type EventMetadata struct {

-	buffer bytes.Buffer

-}

-

-// Bytes returns the raw binary data containing the event metadata. Before being

-// returned, the current size of the buffer is written to the start of the

-// buffer. The returned value is not copied from the internal buffer, so it can

-// be mutated by the EventMetadata object after it is returned.

-func (em *EventMetadata) Bytes() []byte {

-	// Finalize the event metadata buffer by filling in the buffer length at the

-	// beginning.

-	binary.LittleEndian.PutUint16(em.buffer.Bytes(), uint16(em.buffer.Len()))

-	return em.buffer.Bytes()

-}

-

-// WriteEventHeader writes the metadata for the start of an event to the buffer.

-// This specifies the event name and tags.

-func (em *EventMetadata) WriteEventHeader(name string, tags uint32) {

-	binary.Write(&em.buffer, binary.LittleEndian, uint16(0)) // Length placeholder

-	em.writeTags(tags)

-	em.buffer.WriteString(name)

-	em.buffer.WriteByte(0) // Null terminator for name

-}

-

-func (em *EventMetadata) writeField(name string, inType InType, outType OutType, tags uint32, arrSize uint16) {

-	em.buffer.WriteString(name)

-	em.buffer.WriteByte(0) // Null terminator for name

-

-	if outType == OutTypeDefault && tags == 0 {

-		em.buffer.WriteByte(byte(inType))

-	} else {

-		em.buffer.WriteByte(byte(inType | 128))

-		if tags == 0 {

-			em.buffer.WriteByte(byte(outType))

-		} else {

-			em.buffer.WriteByte(byte(outType | 128))

-			em.writeTags(tags)

-		}

-	}

-

-	if arrSize != 0 {

-		binary.Write(&em.buffer, binary.LittleEndian, arrSize)

-	}

-}

-

-// writeTags writes out the tags value to the event metadata. Tags is a 28-bit

-// value, interpreted as bit flags, which are only relevant to the event

-// consumer. The event consumer may choose to attribute special meaning to tags

-// (e.g. 0x4 could mean the field contains PII). Tags are written as a series of

-// bytes, each containing 7 bits of tag value, with the high bit set if there is

-// more tag data in the following byte. This allows for a more compact

-// representation when not all of the tag bits are needed.

-func (em *EventMetadata) writeTags(tags uint32) {

-	// Only use the top 28 bits of the tags value.

-	tags &= 0xfffffff

-

-	for {

-		// Tags are written with the most significant bits (e.g. 21-27) first.

-		val := tags >> 21

-

-		if tags&0x1fffff == 0 {

-			// If there is no more data to write after this, write this value

-			// without the high bit set, and return.

-			em.buffer.WriteByte(byte(val & 0x7f))

-			return

-		}

-

-		em.buffer.WriteByte(byte(val | 0x80))

-

-		tags <<= 7

-	}

-}

-

-// WriteField writes the metadata for a simple field to the buffer.

-func (em *EventMetadata) WriteField(name string, inType InType, outType OutType, tags uint32) {

-	em.writeField(name, inType, outType, tags, 0)

-}

-

-// WriteArray writes the metadata for an array field to the buffer. The number

-// of elements in the array must be written as a uint16 in the event data,

-// immediately preceeding the event data.

-func (em *EventMetadata) WriteArray(name string, inType InType, outType OutType, tags uint32) {

-	em.writeField(name, inType|InTypeArray, outType, tags, 0)

-}

-

-// WriteCountedArray writes the metadata for an array field to the buffer. The

-// size of a counted array is fixed, and the size is written into the metadata

-// directly.

-func (em *EventMetadata) WriteCountedArray(name string, count uint16, inType InType, outType OutType, tags uint32) {

-	em.writeField(name, inType|InTypeCountedArray, outType, tags, count)

-}

-

-// WriteStruct writes the metadata for a nested struct to the buffer. The struct

-// contains the next N fields in the metadata, where N is specified by the

-// fieldCount argument.

-func (em *EventMetadata) WriteStruct(name string, fieldCount uint8, tags uint32) {

-	em.writeField(name, InTypeStruct, OutType(fieldCount), tags, 0)

-}

deleted file mode 100644

@@ -1,63 +0,0 @@

-package etw

-

-import (

-	"golang.org/x/sys/windows"

-)

-

-type eventOptions struct {

-	descriptor        *EventDescriptor

-	activityID        *windows.GUID

-	relatedActivityID *windows.GUID

-	tags              uint32

-}

-

-// EventOpt defines the option function type that can be passed to

-// Provider.WriteEvent to specify general event options, such as level and

-// keyword.

-type EventOpt func(options *eventOptions)

-

-// WithEventOpts returns the variadic arguments as a single slice.

-func WithEventOpts(opts ...EventOpt) []EventOpt {

-	return opts

-}

-

-// WithLevel specifies the level of the event to be written.

-func WithLevel(level Level) EventOpt {

-	return func(options *eventOptions) {

-		options.descriptor.Level = level

-	}

-}

-

-// WithKeyword specifies the keywords of the event to be written. Multiple uses

-// of this option are OR'd together.

-func WithKeyword(keyword uint64) EventOpt {

-	return func(options *eventOptions) {

-		options.descriptor.Keyword |= keyword

-	}

-}

-

-func WithChannel(channel Channel) EventOpt {

-	return func(options *eventOptions) {

-		options.descriptor.Channel = channel

-	}

-}

-

-// WithTags specifies the tags of the event to be written. Tags is a 28-bit

-// value (top 4 bits are ignored) which are interpreted by the event consumer.

-func WithTags(newTags uint32) EventOpt {

-	return func(options *eventOptions) {

-		options.tags |= newTags

-	}

-}

-

-func WithActivityID(activityID *windows.GUID) EventOpt {

-	return func(options *eventOptions) {

-		options.activityID = activityID

-	}

-}

-

-func WithRelatedActivityID(activityID *windows.GUID) EventOpt {

-	return func(options *eventOptions) {

-		options.relatedActivityID = activityID

-	}

-}

deleted file mode 100644

@@ -1,379 +0,0 @@

-package etw

-

-import (

-	"math"

-	"unsafe"

-)

-

-// FieldOpt defines the option function type that can be passed to

-// Provider.WriteEvent to add fields to the event.

-type FieldOpt func(em *EventMetadata, ed *EventData)

-

-// WithFields returns the variadic arguments as a single slice.

-func WithFields(opts ...FieldOpt) []FieldOpt {

-	return opts

-}

-

-// BoolField adds a single bool field to the event.

-func BoolField(name string, value bool) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeUint8, OutTypeBoolean, 0)

-		bool8 := uint8(0)

-		if value {

-			bool8 = uint8(1)

-		}

-		ed.WriteUint8(bool8)

-	}

-}

-

-// BoolArray adds an array of bool to the event.

-func BoolArray(name string, values []bool) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeUint8, OutTypeBoolean, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			bool8 := uint8(0)

-			if v {

-				bool8 = uint8(1)

-			}

-			ed.WriteUint8(bool8)

-		}

-	}

-}

-

-// StringField adds a single string field to the event.

-func StringField(name string, value string) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeANSIString, OutTypeUTF8, 0)

-		ed.WriteString(value)

-	}

-}

-

-// StringArray adds an array of string to the event.

-func StringArray(name string, values []string) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeANSIString, OutTypeUTF8, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteString(v)

-		}

-	}

-}

-

-// IntField adds a single int field to the event.

-func IntField(name string, value int) FieldOpt {

-	switch unsafe.Sizeof(value) {

-	case 4:

-		return Int32Field(name, int32(value))

-	case 8:

-		return Int64Field(name, int64(value))

-	default:

-		panic("Unsupported int size")

-	}

-}

-

-// IntArray adds an array of int to the event.

-func IntArray(name string, values []int) FieldOpt {

-	inType := InTypeNull

-	var writeItem func(*EventData, int)

-	switch unsafe.Sizeof(values[0]) {

-	case 4:

-		inType = InTypeInt32

-		writeItem = func(ed *EventData, item int) { ed.WriteInt32(int32(item)) }

-	case 8:

-		inType = InTypeInt64

-		writeItem = func(ed *EventData, item int) { ed.WriteInt64(int64(item)) }

-	default:

-		panic("Unsupported int size")

-	}

-

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, inType, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			writeItem(ed, v)

-		}

-	}

-}

-

-// Int8Field adds a single int8 field to the event.

-func Int8Field(name string, value int8) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeInt8, OutTypeDefault, 0)

-		ed.WriteInt8(value)

-	}

-}

-

-// Int8Array adds an array of int8 to the event.

-func Int8Array(name string, values []int8) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeInt8, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteInt8(v)

-		}

-	}

-}

-

-// Int16Field adds a single int16 field to the event.

-func Int16Field(name string, value int16) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeInt16, OutTypeDefault, 0)

-		ed.WriteInt16(value)

-	}

-}

-

-// Int16Array adds an array of int16 to the event.

-func Int16Array(name string, values []int16) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeInt16, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteInt16(v)

-		}

-	}

-}

-

-// Int32Field adds a single int32 field to the event.

-func Int32Field(name string, value int32) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeInt32, OutTypeDefault, 0)

-		ed.WriteInt32(value)

-	}

-}

-

-// Int32Array adds an array of int32 to the event.

-func Int32Array(name string, values []int32) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeInt32, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteInt32(v)

-		}

-	}

-}

-

-// Int64Field adds a single int64 field to the event.

-func Int64Field(name string, value int64) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeInt64, OutTypeDefault, 0)

-		ed.WriteInt64(value)

-	}

-}

-

-// Int64Array adds an array of int64 to the event.

-func Int64Array(name string, values []int64) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeInt64, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteInt64(v)

-		}

-	}

-}

-

-// UintField adds a single uint field to the event.

-func UintField(name string, value uint) FieldOpt {

-	switch unsafe.Sizeof(value) {

-	case 4:

-		return Uint32Field(name, uint32(value))

-	case 8:

-		return Uint64Field(name, uint64(value))

-	default:

-		panic("Unsupported uint size")

-	}

-}

-

-// UintArray adds an array of uint to the event.

-func UintArray(name string, values []uint) FieldOpt {

-	inType := InTypeNull

-	var writeItem func(*EventData, uint)

-	switch unsafe.Sizeof(values[0]) {

-	case 4:

-		inType = InTypeUint32

-		writeItem = func(ed *EventData, item uint) { ed.WriteUint32(uint32(item)) }

-	case 8:

-		inType = InTypeUint64

-		writeItem = func(ed *EventData, item uint) { ed.WriteUint64(uint64(item)) }

-	default:

-		panic("Unsupported uint size")

-	}

-

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, inType, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			writeItem(ed, v)

-		}

-	}

-}

-

-// Uint8Field adds a single uint8 field to the event.

-func Uint8Field(name string, value uint8) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeUint8, OutTypeDefault, 0)

-		ed.WriteUint8(value)

-	}

-}

-

-// Uint8Array adds an array of uint8 to the event.

-func Uint8Array(name string, values []uint8) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeUint8, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteUint8(v)

-		}

-	}

-}

-

-// Uint16Field adds a single uint16 field to the event.

-func Uint16Field(name string, value uint16) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeUint16, OutTypeDefault, 0)

-		ed.WriteUint16(value)

-	}

-}

-

-// Uint16Array adds an array of uint16 to the event.

-func Uint16Array(name string, values []uint16) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeUint16, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteUint16(v)

-		}

-	}

-}

-

-// Uint32Field adds a single uint32 field to the event.

-func Uint32Field(name string, value uint32) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeUint32, OutTypeDefault, 0)

-		ed.WriteUint32(value)

-	}

-}

-

-// Uint32Array adds an array of uint32 to the event.

-func Uint32Array(name string, values []uint32) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeUint32, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteUint32(v)

-		}

-	}

-}

-

-// Uint64Field adds a single uint64 field to the event.

-func Uint64Field(name string, value uint64) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeUint64, OutTypeDefault, 0)

-		ed.WriteUint64(value)

-	}

-}

-

-// Uint64Array adds an array of uint64 to the event.

-func Uint64Array(name string, values []uint64) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeUint64, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteUint64(v)

-		}

-	}

-}

-

-// UintptrField adds a single uintptr field to the event.

-func UintptrField(name string, value uintptr) FieldOpt {

-	inType := InTypeNull

-	var writeItem func(*EventData, uintptr)

-	switch unsafe.Sizeof(value) {

-	case 4:

-		inType = InTypeHexInt32

-		writeItem = func(ed *EventData, item uintptr) { ed.WriteUint32(uint32(item)) }

-	case 8:

-		inType = InTypeHexInt64

-		writeItem = func(ed *EventData, item uintptr) { ed.WriteUint64(uint64(item)) }

-	default:

-		panic("Unsupported uintptr size")

-	}

-

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, inType, OutTypeDefault, 0)

-		writeItem(ed, value)

-	}

-}

-

-// UintptrArray adds an array of uintptr to the event.

-func UintptrArray(name string, values []uintptr) FieldOpt {

-	inType := InTypeNull

-	var writeItem func(*EventData, uintptr)

-	switch unsafe.Sizeof(values[0]) {

-	case 4:

-		inType = InTypeHexInt32

-		writeItem = func(ed *EventData, item uintptr) { ed.WriteUint32(uint32(item)) }

-	case 8:

-		inType = InTypeHexInt64

-		writeItem = func(ed *EventData, item uintptr) { ed.WriteUint64(uint64(item)) }

-	default:

-		panic("Unsupported uintptr size")

-	}

-

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, inType, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			writeItem(ed, v)

-		}

-	}

-}

-

-// Float32Field adds a single float32 field to the event.

-func Float32Field(name string, value float32) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeFloat, OutTypeDefault, 0)

-		ed.WriteUint32(math.Float32bits(value))

-	}

-}

-

-// Float32Array adds an array of float32 to the event.

-func Float32Array(name string, values []float32) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeFloat, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteUint32(math.Float32bits(v))

-		}

-	}

-}

-

-// Float64Field adds a single float64 field to the event.

-func Float64Field(name string, value float64) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteField(name, InTypeDouble, OutTypeDefault, 0)

-		ed.WriteUint64(math.Float64bits(value))

-	}

-}

-

-// Float64Array adds an array of float64 to the event.

-func Float64Array(name string, values []float64) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteArray(name, InTypeDouble, OutTypeDefault, 0)

-		ed.WriteUint16(uint16(len(values)))

-		for _, v := range values {

-			ed.WriteUint64(math.Float64bits(v))

-		}

-	}

-}

-

-// Struct adds a nested struct to the event, the FieldOpts in the opts argument

-// are used to specify the fields of the struct.

-func Struct(name string, opts ...FieldOpt) FieldOpt {

-	return func(em *EventMetadata, ed *EventData) {

-		em.WriteStruct(name, uint8(len(opts)), 0)

-		for _, opt := range opts {

-			opt(em, ed)

-		}

-	}

-}

deleted file mode 100644

@@ -1,279 +0,0 @@

-package etw

-

-import (

-	"bytes"

-	"crypto/sha1"

-	"encoding/binary"

-	"encoding/hex"

-	"fmt"

-	"strings"

-	"unicode/utf16"

-	"unsafe"

-

-	"golang.org/x/sys/windows"

-)

-

-// Provider represents an ETW event provider. It is identified by a provider

-// name and ID (GUID), which should always have a 1:1 mapping to each other

-// (e.g. don't use multiple provider names with the same ID, or vice versa).

-type Provider struct {

-	ID         *windows.GUID

-	handle     providerHandle

-	metadata   []byte

-	callback   EnableCallback

-	index      uint

-	enabled    bool

-	level      Level

-	keywordAny uint64

-	keywordAll uint64

-}

-

-// String returns the `provider`.ID as a string

-func (provider *Provider) String() string {

-	data1 := make([]byte, 4)

-	binary.BigEndian.PutUint32(data1, provider.ID.Data1)

-	data2 := make([]byte, 2)

-	binary.BigEndian.PutUint16(data2, provider.ID.Data2)

-	data3 := make([]byte, 2)

-	binary.BigEndian.PutUint16(data3, provider.ID.Data3)

-	return fmt.Sprintf(

-		"%s-%s-%s-%s-%s",

-		hex.EncodeToString(data1),

-		hex.EncodeToString(data2),