table

Documentation

Index

• Constants
• Variables
• type BlockIOMediaInfo
• type EFI_LOCATE_SEARCH_TYPE
• type EfiTime
• type EfiTimeCap
• type OpenProtocolAttributes
  • func (o *OpenProtocolAttributes) String() string
• type SystemTable
• type TableHeader

Constants

const (
	BlockIORevision    = 0
	BlockIOMedia       = 0x8
	BlockIOReset       = 0x10
	BlockIOReadBlocks  = 0x18
	BlockIOWriteBlocks = 0x20
	BlockIOFlushBlocks = 0x28
)

const (
	EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL  = 0x00000001
	EFI_OPEN_PROTOCOL_GET_PROTOCOL        = 0x00000002
	EFI_OPEN_PROTOCOL_TEST_PROTOCOL       = 0x00000004
	EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER = 0x00000008
	EFI_OPEN_PROTOCOL_BY_DRIVER           = 0x00000010
	EFI_OPEN_PROTOCOL_EXCLUSIVE           = 0x00000020
)

const (
	BootServicesOffset                  = 0x60
	RaiseTPL                            = 0x18
	RestoreTPL                          = 0x20
	AllocatePages                       = 0x28
	FreePages                           = 0x30
	GetMemoryMap                        = 0x38
	AllocatePool                        = 0x40
	FreePool                            = 0x48
	CreateEvent                         = 0x50
	SetTimer                            = 0x58
	WaitForEvent                        = 0x60
	SignalEvent                         = 0x68
	CloseEvent                          = 0x70
	CheckEvent                          = 0x78
	InstallProtocolInterface            = 0x80
	ReinstallProtocolInterface          = 0x88
	UninstallProtocolInterface          = 0x90
	HandleProtocol                      = 0x98
	PCHandleProtocol                    = 0xa0
	RegisterProtocolNotify              = 0xa8
	LocateHandle                        = 0xb0
	LocateDevicePath                    = 0xb8
	InstallConfigurationTable           = 0xc0
	LoadImage                           = 0xc8
	StartImage                          = 0xd0
	Exit                                = 0xd8
	UnloadImage                         = 0xe0
	ExitBootServices                    = 0xe8
	GetNextMonotonicCount               = 0xf0
	Stall                               = 0xf8
	SetWatchdogTimer                    = 0x100
	ConnectController                   = 0x108
	DisconnectController                = 0x110
	OpenProtocol                        = 0x118
	CloseProtocol                       = 0x120
	OpenProtocolInformation             = 0x128
	ProtocolsPerHandle                  = 0x130
	LocateHandleBuffer                  = 0x138
	LocateProtocol                      = 0x140
	InstallMultipleProtocolInterfaces   = 0x148
	UninstallMultipleProtocolInterfaces = 0x150
	CalculateCrc32                      = 0x158
	CopyMem                             = 0x160
	SetMem                              = 0x168
	CreateEventEx                       = 0x170
)

These are the offsets of various UEFI boot services.

const (
	CollStriColl           = 0
	CollMetaiMatch         = 0x8
	CollStrLwr             = 0x10
	CollStrUpr             = 0x18
	CollFatToStr           = 0x20
	CollStrToFat           = 0x28
	CollSupportedLanguages = 0x30
)

const (
	STOutReset             = 0
	STOutOutputString      = 0x8
	STOutTestString        = 0x10
	STOutQueryMode         = 0x18
	STOutSetMode           = 0x20
	STOutSetAttribute      = 0x28
	STOutClearScreen       = 0x30
	STOutSetCursorPosition = 0x38
	STOutEnableCursor      = 0x40
	STOutMode              = 0x48
)

const (
	STInReset         = 0
	STInReadKeyStroke = 0x8
	STInWaitForKey    = 0x10
)

const (
	STModeMaxMode       = 0
	STModeMode          = 0x4
	STModeAttribute     = 0x8
	STModeCursorColumn  = 0xc
	STModeCursorRow     = 0x10
	STModeCursorVisible = 0x14
)

const (
	LIRevision        = 0
	LIParentHandle    = 0x8
	LISystemTable     = 0x10
	LIDeviceHandle    = 0x18
	LIFilePath        = 0x20
	LIReserved        = 0x28
	LILoadOptionsSize = 0x30
	LILoadOptions     = 0x38
	LIImageBase       = 0x40
	LIImageSize       = 0x48
	LIImageCodeType   = 0x50
	LIImageDataType   = 0x54
	LIUnload          = 0x58
)

const (
	RTHdr                       = 0
	RTGetTime                   = 0x18
	RTSetTime                   = 0x20
	RTGetWakeupTime             = 0x28
	RTSetWakeupTime             = 0x30
	RTSetVirtualAddressMap      = 0x38
	RTConvertPointer            = 0x40
	RTGetVariable               = 0x48
	RTGetNextVariableName       = 0x50
	RTSetVariable               = 0x58
	RTGetNextHighMonotonicCount = 0x60
	RTResetSystem               = 0x68
	RTUpdateCapsule             = 0x70
	RTQueryCapsuleCapabilities  = 0x78
	RTQueryVariableInfo         = 0x80
)

const (
	Hdr                  = 0
	FirmwareVendor       = 0x18
	FirmwareRevision     = 0x20
	ConInHandle          = 0x28
	ConIn                = 0x30
	ConOutHandle         = 0x38
	ConOut               = 0x40
	StdErrHandle         = 0x48
	StdErr               = 0x50
	RuntimeServices      = 0x58
	BootServices         = 0x60
	NumberOfTableEntries = 0x68
	ConfigurationTable   = 0x70
)

const BlockIOGUID = "964E5B21-6459-11D2-8E39-00A0C969723B"

const (
	EfiHandleSize = 8
)

Variables

var BlockIOServiceNames = map[uint64]*val{
	BlockIORevision:    {N: "Revision"},
	BlockIOMedia:       {N: "Media"},
	BlockIOReset:       {N: "Reset"},
	BlockIOReadBlocks:  {N: "ReadBlocks"},
	BlockIOWriteBlocks: {N: "WriteBlocks"},
	BlockIOFlushBlocks: {N: "FlushBlocks"},
}

var BootServicesNames = map[int]string{
	RaiseTPL:                            "RaiseTPL",
	RestoreTPL:                          "RestoreTPL",
	AllocatePages:                       "AllocatePages",
	FreePages:                           "FreePages",
	GetMemoryMap:                        "GetMemoryMap",
	AllocatePool:                        "AllocatePool",
	FreePool:                            "FreePool",
	CreateEvent:                         "CreateEvent",
	SetTimer:                            "SetTimer",
	WaitForEvent:                        "WaitForEvent",
	SignalEvent:                         "SignalEvent",
	CloseEvent:                          "CloseEvent",
	CheckEvent:                          "CheckEvent",
	InstallProtocolInterface:            "InstallProtocolInterface",
	ReinstallProtocolInterface:          "ReinstallProtocolInterface",
	UninstallProtocolInterface:          "UninstallProtocolInterface",
	HandleProtocol:                      "HandleProtocol",
	PCHandleProtocol:                    "PCHandleProtocol",
	RegisterProtocolNotify:              "RegisterProtocolNotify",
	LocateHandle:                        "LocateHandle",
	LocateDevicePath:                    "LocateDevicePath",
	InstallConfigurationTable:           "InstallConfigurationTable",
	LoadImage:                           "LoadImage",
	StartImage:                          "StartImage",
	Exit:                                "Exit",
	UnloadImage:                         "UnloadImage",
	ExitBootServices:                    "ExitBootServices",
	GetNextMonotonicCount:               "GetNextMonotonicCount",
	Stall:                               "Stall",
	SetWatchdogTimer:                    "SetWatchdogTimer",
	ConnectController:                   "ConnectController",
	DisconnectController:                "DisconnectController",
	OpenProtocol:                        "OpenProtocol",
	CloseProtocol:                       "CloseProtocol",
	OpenProtocolInformation:             "OpenProtocolInformation",
	ProtocolsPerHandle:                  "ProtocolsPerHandle",
	LocateHandleBuffer:                  "LocateHandleBuffer",
	LocateProtocol:                      "LocateProtocol",
	InstallMultipleProtocolInterfaces:   "InstallMultipleProtocolInterfaces",
	UninstallMultipleProtocolInterfaces: "UninstallMultipleProtocolInterfaces",
	CalculateCrc32:                      "CalculateCrc32",
	CopyMem:                             "CopyMem",
	SetMem:                              "SetMem",
	CreateEventEx:                       "CreateEventEx",
}

BootServicesNames maps an int to a name

var CollateServicesNames = map[uint64]*val{
	CollStriColl:           {N: "StriColl"},
	CollMetaiMatch:         {N: "MetaiMatch"},
	CollStrLwr:             {N: "StrLwr"},
	CollStrUpr:             {N: "StrUpr"},
	CollFatToStr:           {N: "FatToStr"},
	CollStrToFat:           {N: "StrToFat"},
	CollSupportedLanguages: {N: "SupportedLanguages"},
}

var LoadedImageTableNames = map[uint64]*val{
	LIRevision:        {N: "Revision"},
	LIParentHandle:    {N: "ParentHandle"},
	LISystemTable:     {N: "SystemTable"},
	LIDeviceHandle:    {N: "DeviceHandle"},
	LIFilePath:        {N: "FilePath"},
	LIReserved:        {N: "Reserved"},
	LILoadOptionsSize: {N: "LoadOptionsSize"},
	LILoadOptions:     {N: "LoadOptions"},
	LIImageBase:       {N: "ImageBase"},
	LIImageSize:       {N: "ImageSize"},
	LIImageCodeType:   {N: "ImageCodeType"},
	LIImageDataType:   {N: "ImageDataType"},
	LIUnload:          {N: "Unload"},
}

var RuntimeServicesNames = map[uint64]*val{
	RTHdr:                       &val{N: "Hdr"},
	RTGetTime:                   &val{N: "GetTime"},
	RTSetTime:                   &val{N: "SetTime"},
	RTGetWakeupTime:             &val{N: "GetWakeupTime"},
	RTSetWakeupTime:             &val{N: "SetWakeupTime"},
	RTSetVirtualAddressMap:      &val{N: "SetVirtualAddressMap"},
	RTConvertPointer:            &val{N: "ConvertPointer"},
	RTGetVariable:               &val{N: "GetVariable"},
	RTGetNextVariableName:       &val{N: "GetNextVariableName"},
	RTSetVariable:               &val{N: "SetVariable"},
	RTGetNextHighMonotonicCount: &val{N: "GetNextHighMonotonicCount"},
	RTResetSystem:               &val{N: "ResetSystem"},
	RTUpdateCapsule:             &val{N: "UpdateCapsule"},
	RTQueryCapsuleCapabilities:  &val{N: "QueryCapsuleCapabilities"},
	RTQueryVariableInfo:         &val{N: "QueryVariableInfo"},
}

var SearchTypeNames = map[EFI_LOCATE_SEARCH_TYPE]string{
	AllHandles:       "AllHandles",
	ByRegisterNotify: "ByRegisterNotify",
	ByProtocol:       "ByProtocol",
}

var SimpleTextInServicesNames = map[uint64]*val{
	STInReset:         {N: "Reset"},
	STInReadKeyStroke: {N: "ReadKeyStroke"},
	STInWaitForKey:    {N: "WaitForKey"},
}

var SimpleTextModeServicesNames = map[uint64]*val{
	STModeMaxMode:       {N: "MaxMode"},
	STModeMode:          {N: "Mode"},
	STModeAttribute:     {N: "Attribute"},
	STModeCursorColumn:  {N: "CursorColumn"},
	STModeCursorRow:     {N: "CursorRow"},
	STModeCursorVisible: {N: "CursorVisible"},
}

var SimpleTextOutServicesNames = map[uint64]*val{
	STOutReset:             {N: "Reset"},
	STOutOutputString:      {N: "OutputString"},
	STOutTestString:        {N: "TestString"},
	STOutQueryMode:         {N: "QueryMode"},
	STOutSetMode:           {N: "SetMode"},
	STOutSetAttribute:      {N: "SetAttribute"},
	STOutClearScreen:       {N: "ClearScreen"},
	STOutSetCursorPosition: {N: "SetCursorPosition"},
	STOutEnableCursor:      {N: "EnableCursor"},
	STOutMode:              {N: "Mode"},
}

var SystemSig = []byte{0x54, 0x53, 0x59, 0x53, 0x20, 0x49, 0x42, 0x49}

var SystemTableNames = map[uint64]*val{
	Hdr:                  {N: "Hdr"},
	FirmwareVendor:       {N: "FirmwareVendor"},
	FirmwareRevision:     {N: "FirmwareRevision"},
	ConInHandle:          {N: "ConInHandle"},
	ConIn:                {N: "ConIn"},
	ConOutHandle:         {N: "ConOutHandle"},
	ConOut:               {N: "ConOut"},
	StdErrHandle:         {N: "StdErrHandle"},
	StdErr:               {N: "StdErr"},
	RuntimeServices:      {N: "RuntimeServices"},
	BootServices:         {N: "BootServices"},
	NumberOfTableEntries: {N: "NumberOfTableEntries"},
	ConfigurationTable:   {N: "ConfigurationTable"},
}

SystemTableNames provide names and values for system table entries.

Types

type BlockIOMediaInfo

type BlockIOMediaInfo struct {
	MediaId          uint32
	RemovableMedia   uint32
	MediaPresent     uint32
	LogicalPartition uint32
	ReadOnly         uint32
	WriteCaching     uint32
	BlockSize        uint32
	IoAlign          uint32
	LastBlock        uint64
}

type EFI_LOCATE_SEARCH_TYPE

type EFI_LOCATE_SEARCH_TYPE uint32

const (
	AllHandles       EFI_LOCATE_SEARCH_TYPE = 0
	ByRegisterNotify EFI_LOCATE_SEARCH_TYPE = 1
	ByProtocol       EFI_LOCATE_SEARCH_TYPE = 2
)

type EfiTime

type EfiTime struct {
	Year   uint16
	Month  uint8
	Day    uint8
	Hour   uint8
	Minute uint8
	Second uint8

	Nanosecond uint32
	Timezone   int16
	Daylight   uint8
	// contains filtered or unexported fields
}

type EfiTimeCap

type EfiTimeCap struct {
	Resolution uint32
	Accuracy   uint32
	SetsToZero uint8
}

type OpenProtocolAttributes

type OpenProtocolAttributes uint32

func (*OpenProtocolAttributes) String

func (o *OpenProtocolAttributes) String() string

type SystemTable

type SystemTable struct {
	TableHeader

	Vendor           uint16
	Revision         uint32
	FirmwareVendor   uintptr
	FirmwareRevision uint32

	ConInHandle uintptr
	ConIn       uintptr

	ConOutHandle uintptr
	ConOut       uintptr

	StdErrHandle uintptr
	StdErr       uintptr

	RuntimeServices uintptr
	BootServices    uintptr

	NumberOfTableEntries uintptr
	ConfigurationTable   uintptr
}

type TableHeader

type TableHeader struct {
	Signature  uint64
	Revision   uint32
	HeaderSize uint32
	CRC32      uint32
	Reserved   uint32
}