* [Xen-devel] [PATCH v3 01/22] golang/xenlight: generate enum types from IDL
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-16 17:07 ` George Dunlap
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 02/22] golang/xenlight: define Defbool builtin type Nick Rosbrook
` (20 subsequent siblings)
21 siblings, 1 reply; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Introduce gengotypes.py to generate Go code the from IDL. As a first step,
implement 'enum' type generation.
As a result of the newly-generated code, remove the existing, and now
conflicting definitions in xenlight.go. In the case of the Error type,
rename the slice 'errors' to 'libxlErrors' so that it does not conflict
with the standard library package 'errors.' And, negate the values used
in 'libxlErrors' since the generated error values are negative.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
Changes in v2:
- Introduce Makefile targets for code generation
- Re-generate Go code (includes new libxl_passtrhough enum).
- Use *.gen.go naming convention for generated Go files.
---
tools/golang/xenlight/Makefile | 18 +-
tools/golang/xenlight/gengotypes.py | 109 ++++++++
tools/golang/xenlight/types.gen.go | 388 ++++++++++++++++++++++++++++
tools/golang/xenlight/xenlight.go | 140 ++--------
4 files changed, 535 insertions(+), 120 deletions(-)
create mode 100644 tools/golang/xenlight/gengotypes.py
create mode 100644 tools/golang/xenlight/types.gen.go
diff --git a/tools/golang/xenlight/Makefile b/tools/golang/xenlight/Makefile
index 0987305224..681f32c234 100644
--- a/tools/golang/xenlight/Makefile
+++ b/tools/golang/xenlight/Makefile
@@ -7,20 +7,21 @@ GOCODE_DIR ?= $(prefix)/share/gocode/
GOXL_PKG_DIR = /src/$(XEN_GOCODE_URL)/xenlight/
GOXL_INSTALL_DIR = $(GOCODE_DIR)$(GOXL_PKG_DIR)
-# PKGSOURCES: Files which comprise the distributed source package
-PKGSOURCES = xenlight.go
-
GO ?= go
.PHONY: all
all: build
.PHONY: package
-package: $(XEN_GOPATH)$(GOXL_PKG_DIR)$(PKGSOURCES)
+package: $(XEN_GOPATH)$(GOXL_PKG_DIR)
-$(XEN_GOPATH)/src/$(XEN_GOCODE_URL)/xenlight/$(PKGSOURCES): $(PKGSOURCES)
+$(XEN_GOPATH)/src/$(XEN_GOCODE_URL)/xenlight/: %.gen.go
$(INSTALL_DIR) $(XEN_GOPATH)$(GOXL_PKG_DIR)
- $(INSTALL_DATA) $(PKGSOURCES) $(XEN_GOPATH)$(GOXL_PKG_DIR)
+ $(INSTALL_DATA) xenlight.go $(XEN_GOPATH)$(GOXL_PKG_DIR)
+ $(INSTALL_DATA) types.gen.go $(XEN_GOPATH)$(GOXL_PKG_DIR)
+
+%.gen.go: gengotypes.py $(XEN_ROOT)/tools/libxl/libxl_types.idl $(XEN_ROOT)/tools/libxl/idl.py
+ XEN_ROOT=$(XEN_ROOT) $(PYTHON) gengotypes.py ../../libxl/libxl_types.idl
# Go will do its own dependency checking, and not actuall go through
# with the build if none of the input files have changed.
@@ -36,10 +37,11 @@ build: package
.PHONY: install
install: build
$(INSTALL_DIR) $(DESTDIR)$(GOXL_INSTALL_DIR)
- $(INSTALL_DATA) $(XEN_GOPATH)$(GOXL_PKG_DIR)$(PKGSOURCES) $(DESTDIR)$(GOXL_INSTALL_DIR)
+ $(INSTALL_DATA) $(XEN_GOPATH)$(GOXL_PKG_DIR)xenlight.go $(DESTDIR)$(GOXL_INSTALL_DIR)
+ $(INSTALL_DATA) $(XEN_GOPATH)$(GOXL_PKG_DIR)types.gen.go $(DESTDIR)$(GOXL_INSTALL_DIR)
.PHONY: uninstall
- rm -f $(addprefix $(DESTDIR)$(GOXL_INSTALL_DIR)/, $(PKGSOURCES))
+ rm -rf $(DESTDIR)$(GOXL_INSTALL_DIR)
.PHONY: clean
clean:
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
new file mode 100644
index 0000000000..2211541547
--- /dev/null
+++ b/tools/golang/xenlight/gengotypes.py
@@ -0,0 +1,109 @@
+#!/usr/bin/python
+
+import os
+import sys
+
+sys.path.append('{}/tools/libxl'.format(os.environ['XEN_ROOT']))
+import idl
+
+# Go versions of some builtin types.
+# Append the libxl-defined builtins after IDL parsing.
+builtin_type_names = {
+ idl.bool.typename: 'bool',
+ idl.string.typename: 'string',
+ idl.integer.typename: 'int',
+ idl.uint8.typename: 'byte',
+ idl.uint16.typename: 'uint16',
+ idl.uint32.typename: 'uint32',
+ idl.uint64.typename: 'uint64',
+}
+
+def xenlight_golang_generate_types(path = None, types = None, comment = None):
+ """
+ Generate a .go file (types.gen.go by default)
+ that contains a Go type for each type in types.
+ """
+ if path is None:
+ path = 'types.gen.go'
+
+ with open(path, 'w') as f:
+ if comment is not None:
+ f.write(comment)
+ f.write('package xenlight\n')
+
+ for ty in types:
+ f.write(xenlight_golang_type_define(ty))
+ f.write('\n')
+
+ go_fmt(path)
+
+def xenlight_golang_type_define(ty = None):
+ s = ''
+
+ if isinstance(ty, idl.Enumeration):
+ s += xenlight_golang_define_enum(ty)
+
+ return s
+
+def xenlight_golang_define_enum(ty = None):
+ s = ''
+ typename = ''
+
+ if ty.typename is not None:
+ typename = xenlight_golang_fmt_name(ty.typename)
+ s += 'type {} int\n'.format(typename)
+
+ # Start const block
+ s += 'const(\n'
+
+ for v in ty.values:
+ name = xenlight_golang_fmt_name(v.name)
+ s += '{} {} = {}\n'.format(name, typename, v.value)
+
+ # End const block
+ s += ')\n'
+
+ return s
+
+def xenlight_golang_fmt_name(name, exported = True):
+ """
+ Take a given type name and return an
+ appropriate Go type name.
+ """
+ if name in builtin_type_names.keys():
+ return builtin_type_names[name]
+
+ # Name is not a builtin, format it for Go.
+ words = name.split('_')
+
+ # Remove 'libxl' prefix
+ if words[0].lower() == 'libxl':
+ words.remove(words[0])
+
+ if exported:
+ return ''.join(x.title() for x in words)
+
+ return words[0] + ''.join(x.title() for x in words[1:])
+
+def go_fmt(path):
+ """ Call go fmt on the given path. """
+ os.system('go fmt {}'.format(path))
+
+if __name__ == '__main__':
+ idlname = sys.argv[1]
+
+ (builtins, types) = idl.parse(idlname)
+
+ for b in builtins:
+ name = b.typename
+ builtin_type_names[name] = xenlight_golang_fmt_name(name)
+
+ header_comment="""// DO NOT EDIT.
+ //
+ // This file is generated by:
+ // {}
+ //
+ """.format(' '.join(sys.argv))
+
+ xenlight_golang_generate_types(types=types,
+ comment=header_comment)
diff --git a/tools/golang/xenlight/types.gen.go b/tools/golang/xenlight/types.gen.go
new file mode 100644
index 0000000000..4a52eab048
--- /dev/null
+++ b/tools/golang/xenlight/types.gen.go
@@ -0,0 +1,388 @@
+// DO NOT EDIT.
+//
+// This file is generated by:
+// gengotypes.py ../../libxl/libxl_types.idl
+//
+package xenlight
+
+type Error int
+
+const (
+ ErrorNonspecific Error = -1
+ ErrorVersion Error = -2
+ ErrorFail Error = -3
+ ErrorNi Error = -4
+ ErrorNomem Error = -5
+ ErrorInval Error = -6
+ ErrorBadfail Error = -7
+ ErrorGuestTimedout Error = -8
+ ErrorTimedout Error = -9
+ ErrorNoparavirt Error = -10
+ ErrorNotReady Error = -11
+ ErrorOseventRegFail Error = -12
+ ErrorBufferfull Error = -13
+ ErrorUnknownChild Error = -14
+ ErrorLockFail Error = -15
+ ErrorJsonConfigEmpty Error = -16
+ ErrorDeviceExists Error = -17
+ ErrorCheckpointDevopsDoesNotMatch Error = -18
+ ErrorCheckpointDeviceNotSupported Error = -19
+ ErrorVnumaConfigInvalid Error = -20
+ ErrorDomainNotfound Error = -21
+ ErrorAborted Error = -22
+ ErrorNotfound Error = -23
+ ErrorDomainDestroyed Error = -24
+ ErrorFeatureRemoved Error = -25
+ ErrorProtocolErrorQmp Error = -26
+ ErrorUnknownQmpError Error = -27
+ ErrorQmpGenericError Error = -28
+ ErrorQmpCommandNotFound Error = -29
+ ErrorQmpDeviceNotActive Error = -30
+ ErrorQmpDeviceNotFound Error = -31
+ ErrorQemuApi Error = -32
+)
+
+type DomainType int
+
+const (
+ DomainTypeInvalid DomainType = -1
+ DomainTypeHvm DomainType = 1
+ DomainTypePv DomainType = 2
+ DomainTypePvh DomainType = 3
+)
+
+type RdmReserveStrategy int
+
+const (
+ RdmReserveStrategyIgnore RdmReserveStrategy = 0
+ RdmReserveStrategyHost RdmReserveStrategy = 1
+)
+
+type RdmReservePolicy int
+
+const (
+ RdmReservePolicyInvalid RdmReservePolicy = -1
+ RdmReservePolicyStrict RdmReservePolicy = 0
+ RdmReservePolicyRelaxed RdmReservePolicy = 1
+)
+
+type ChannelConnection int
+
+const (
+ ChannelConnectionUnknown ChannelConnection = 0
+ ChannelConnectionPty ChannelConnection = 1
+ ChannelConnectionSocket ChannelConnection = 2
+)
+
+type DeviceModelVersion int
+
+const (
+ DeviceModelVersionUnknown DeviceModelVersion = 0
+ DeviceModelVersionQemuXenTraditional DeviceModelVersion = 1
+ DeviceModelVersionQemuXen DeviceModelVersion = 2
+)
+
+type ConsoleType int
+
+const (
+ ConsoleTypeUnknown ConsoleType = 0
+ ConsoleTypeSerial ConsoleType = 1
+ ConsoleTypePv ConsoleType = 2
+ ConsoleTypeVuart ConsoleType = 3
+)
+
+type DiskFormat int
+
+const (
+ DiskFormatUnknown DiskFormat = 0
+ DiskFormatQcow DiskFormat = 1
+ DiskFormatQcow2 DiskFormat = 2
+ DiskFormatVhd DiskFormat = 3
+ DiskFormatRaw DiskFormat = 4
+ DiskFormatEmpty DiskFormat = 5
+ DiskFormatQed DiskFormat = 6
+)
+
+type DiskBackend int
+
+const (
+ DiskBackendUnknown DiskBackend = 0
+ DiskBackendPhy DiskBackend = 1
+ DiskBackendTap DiskBackend = 2
+ DiskBackendQdisk DiskBackend = 3
+)
+
+type NicType int
+
+const (
+ NicTypeUnknown NicType = 0
+ NicTypeVifIoemu NicType = 1
+ NicTypeVif NicType = 2
+)
+
+type ActionOnShutdown int
+
+const (
+ ActionOnShutdownDestroy ActionOnShutdown = 1
+ ActionOnShutdownRestart ActionOnShutdown = 2
+ ActionOnShutdownRestartRename ActionOnShutdown = 3
+ ActionOnShutdownPreserve ActionOnShutdown = 4
+ ActionOnShutdownCoredumpDestroy ActionOnShutdown = 5
+ ActionOnShutdownCoredumpRestart ActionOnShutdown = 6
+ ActionOnShutdownSoftReset ActionOnShutdown = 7
+)
+
+type Trigger int
+
+const (
+ TriggerUnknown Trigger = 0
+ TriggerPower Trigger = 1
+ TriggerSleep Trigger = 2
+ TriggerNmi Trigger = 3
+ TriggerInit Trigger = 4
+ TriggerReset Trigger = 5
+ TriggerS3Resume Trigger = 6
+)
+
+type TscMode int
+
+const (
+ TscModeDefault TscMode = 0
+ TscModeAlwaysEmulate TscMode = 1
+ TscModeNative TscMode = 2
+ TscModeNativeParavirt TscMode = 3
+)
+
+type GfxPassthruKind int
+
+const (
+ GfxPassthruKindDefault GfxPassthruKind = 0
+ GfxPassthruKindIgd GfxPassthruKind = 1
+)
+
+type TimerMode int
+
+const (
+ TimerModeUnknown TimerMode = -1
+ TimerModeDelayForMissedTicks TimerMode = 0
+ TimerModeNoDelayForMissedTicks TimerMode = 1
+ TimerModeNoMissedTicksPending TimerMode = 2
+ TimerModeOneMissedTickPending TimerMode = 3
+)
+
+type BiosType int
+
+const (
+ BiosTypeUnknown BiosType = 0
+ BiosTypeRombios BiosType = 1
+ BiosTypeSeabios BiosType = 2
+ BiosTypeOvmf BiosType = 3
+)
+
+type Scheduler int
+
+const (
+ SchedulerUnknown Scheduler = 0
+ SchedulerSedf Scheduler = 4
+ SchedulerCredit Scheduler = 5
+ SchedulerCredit2 Scheduler = 6
+ SchedulerArinc653 Scheduler = 7
+ SchedulerRtds Scheduler = 8
+ SchedulerNull Scheduler = 9
+)
+
+type ShutdownReason int
+
+const (
+ ShutdownReasonUnknown ShutdownReason = -1
+ ShutdownReasonPoweroff ShutdownReason = 0
+ ShutdownReasonReboot ShutdownReason = 1
+ ShutdownReasonSuspend ShutdownReason = 2
+ ShutdownReasonCrash ShutdownReason = 3
+ ShutdownReasonWatchdog ShutdownReason = 4
+ ShutdownReasonSoftReset ShutdownReason = 5
+)
+
+type VgaInterfaceType int
+
+const (
+ VgaInterfaceTypeUnknown VgaInterfaceType = 0
+ VgaInterfaceTypeCirrus VgaInterfaceType = 1
+ VgaInterfaceTypeStd VgaInterfaceType = 2
+ VgaInterfaceTypeNone VgaInterfaceType = 3
+ VgaInterfaceTypeQxl VgaInterfaceType = 4
+)
+
+type VendorDevice int
+
+const (
+ VendorDeviceNone VendorDevice = 0
+ VendorDeviceXenserver VendorDevice = 1
+)
+
+type ViridianEnlightenment int
+
+const (
+ ViridianEnlightenmentBase ViridianEnlightenment = 0
+ ViridianEnlightenmentFreq ViridianEnlightenment = 1
+ ViridianEnlightenmentTimeRefCount ViridianEnlightenment = 2
+ ViridianEnlightenmentReferenceTsc ViridianEnlightenment = 3
+ ViridianEnlightenmentHcallRemoteTlbFlush ViridianEnlightenment = 4
+ ViridianEnlightenmentApicAssist ViridianEnlightenment = 5
+ ViridianEnlightenmentCrashCtl ViridianEnlightenment = 6
+ ViridianEnlightenmentSynic ViridianEnlightenment = 7
+ ViridianEnlightenmentStimer ViridianEnlightenment = 8
+ ViridianEnlightenmentHcallIpi ViridianEnlightenment = 9
+)
+
+type Hdtype int
+
+const (
+ HdtypeIde Hdtype = 1
+ HdtypeAhci Hdtype = 2
+)
+
+type CheckpointedStream int
+
+const (
+ CheckpointedStreamNone CheckpointedStream = 0
+ CheckpointedStreamRemus CheckpointedStream = 1
+ CheckpointedStreamColo CheckpointedStream = 2
+)
+
+type VuartType int
+
+const (
+ VuartTypeUnknown VuartType = 0
+ VuartTypeSbsaUart VuartType = 1
+)
+
+type VkbBackend int
+
+const (
+ VkbBackendUnknown VkbBackend = 0
+ VkbBackendQemu VkbBackend = 1
+ VkbBackendLinux VkbBackend = 2
+)
+
+type Passthrough int
+
+const (
+ PassthroughDefault Passthrough = 0
+ PassthroughDisabled Passthrough = 1
+ PassthroughEnabled Passthrough = 2
+ PassthroughSyncPt Passthrough = 3
+ PassthroughSharePt Passthrough = 4
+)
+
+type GicVersion int
+
+const (
+ GicVersionDefault GicVersion = 0
+ GicVersionV2 GicVersion = 32
+ GicVersionV3 GicVersion = 48
+)
+
+type TeeType int
+
+const (
+ TeeTypeNone TeeType = 0
+ TeeTypeOptee TeeType = 1
+)
+
+type Altp2MMode int
+
+const (
+ Altp2MModeDisabled Altp2MMode = 0
+ Altp2MModeMixed Altp2MMode = 1
+ Altp2MModeExternal Altp2MMode = 2
+ Altp2MModeLimited Altp2MMode = 3
+)
+
+type UsbctrlType int
+
+const (
+ UsbctrlTypeAuto UsbctrlType = 0
+ UsbctrlTypePv UsbctrlType = 1
+ UsbctrlTypeDevicemodel UsbctrlType = 2
+ UsbctrlTypeQusb UsbctrlType = 3
+)
+
+type UsbdevType int
+
+const (
+ UsbdevTypeHostdev UsbdevType = 1
+)
+
+type VsndPcmFormat int
+
+const (
+ VsndPcmFormatS8 VsndPcmFormat = 1
+ VsndPcmFormatU8 VsndPcmFormat = 2
+ VsndPcmFormatS16Le VsndPcmFormat = 3
+ VsndPcmFormatS16Be VsndPcmFormat = 4
+ VsndPcmFormatU16Le VsndPcmFormat = 5
+ VsndPcmFormatU16Be VsndPcmFormat = 6
+ VsndPcmFormatS24Le VsndPcmFormat = 7
+ VsndPcmFormatS24Be VsndPcmFormat = 8
+ VsndPcmFormatU24Le VsndPcmFormat = 9
+ VsndPcmFormatU24Be VsndPcmFormat = 10
+ VsndPcmFormatS32Le VsndPcmFormat = 11
+ VsndPcmFormatS32Be VsndPcmFormat = 12
+ VsndPcmFormatU32Le VsndPcmFormat = 13
+ VsndPcmFormatU32Be VsndPcmFormat = 14
+ VsndPcmFormatF32Le VsndPcmFormat = 15
+ VsndPcmFormatF32Be VsndPcmFormat = 16
+ VsndPcmFormatF64Le VsndPcmFormat = 17
+ VsndPcmFormatF64Be VsndPcmFormat = 18
+ VsndPcmFormatIec958SubframeLe VsndPcmFormat = 19
+ VsndPcmFormatIec958SubframeBe VsndPcmFormat = 20
+ VsndPcmFormatMuLaw VsndPcmFormat = 21
+ VsndPcmFormatALaw VsndPcmFormat = 22
+ VsndPcmFormatImaAdpcm VsndPcmFormat = 23
+ VsndPcmFormatMpeg VsndPcmFormat = 24
+ VsndPcmFormatGsm VsndPcmFormat = 25
+)
+
+type VsndStreamType int
+
+const (
+ VsndStreamTypeP VsndStreamType = 1
+ VsndStreamTypeC VsndStreamType = 2
+)
+
+type EventType int
+
+const (
+ EventTypeDomainShutdown EventType = 1
+ EventTypeDomainDeath EventType = 2
+ EventTypeDiskEject EventType = 3
+ EventTypeOperationComplete EventType = 4
+ EventTypeDomainCreateConsoleAvailable EventType = 5
+)
+
+type PsrCmtType int
+
+const (
+ PsrCmtTypeCacheOccupancy PsrCmtType = 1
+ PsrCmtTypeTotalMemCount PsrCmtType = 2
+ PsrCmtTypeLocalMemCount PsrCmtType = 3
+)
+
+type PsrCbmType int
+
+const (
+ PsrCbmTypeUnknown PsrCbmType = 0
+ PsrCbmTypeL3Cbm PsrCbmType = 1
+ PsrCbmTypeL3CbmCode PsrCbmType = 2
+ PsrCbmTypeL3CbmData PsrCbmType = 3
+ PsrCbmTypeL2Cbm PsrCbmType = 4
+ PsrCbmTypeMbaThrtl PsrCbmType = 5
+)
+
+type PsrFeatType int
+
+const (
+ PsrFeatTypeCat PsrFeatType = 1
+ PsrFeatTypeMba PsrFeatType = 2
+)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 902cbb839e..89ed439fd0 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -37,77 +37,42 @@ import (
"unsafe"
)
-/*
- * Errors
- */
-
-type Error int
-
-const (
- ErrorNonspecific = Error(-C.ERROR_NONSPECIFIC)
- ErrorVersion = Error(-C.ERROR_VERSION)
- ErrorFail = Error(-C.ERROR_FAIL)
- ErrorNi = Error(-C.ERROR_NI)
- ErrorNomem = Error(-C.ERROR_NOMEM)
- ErrorInval = Error(-C.ERROR_INVAL)
- ErrorBadfail = Error(-C.ERROR_BADFAIL)
- ErrorGuestTimedout = Error(-C.ERROR_GUEST_TIMEDOUT)
- ErrorTimedout = Error(-C.ERROR_TIMEDOUT)
- ErrorNoparavirt = Error(-C.ERROR_NOPARAVIRT)
- ErrorNotReady = Error(-C.ERROR_NOT_READY)
- ErrorOseventRegFail = Error(-C.ERROR_OSEVENT_REG_FAIL)
- ErrorBufferfull = Error(-C.ERROR_BUFFERFULL)
- ErrorUnknownChild = Error(-C.ERROR_UNKNOWN_CHILD)
- ErrorLockFail = Error(-C.ERROR_LOCK_FAIL)
- ErrorJsonConfigEmpty = Error(-C.ERROR_JSON_CONFIG_EMPTY)
- ErrorDeviceExists = Error(-C.ERROR_DEVICE_EXISTS)
- ErrorCheckpointDevopsDoesNotMatch = Error(-C.ERROR_CHECKPOINT_DEVOPS_DOES_NOT_MATCH)
- ErrorCheckpointDeviceNotSupported = Error(-C.ERROR_CHECKPOINT_DEVICE_NOT_SUPPORTED)
- ErrorVnumaConfigInvalid = Error(-C.ERROR_VNUMA_CONFIG_INVALID)
- ErrorDomainNotfound = Error(-C.ERROR_DOMAIN_NOTFOUND)
- ErrorAborted = Error(-C.ERROR_ABORTED)
- ErrorNotfound = Error(-C.ERROR_NOTFOUND)
- ErrorDomainDestroyed = Error(-C.ERROR_DOMAIN_DESTROYED)
- ErrorFeatureRemoved = Error(-C.ERROR_FEATURE_REMOVED)
-)
-
-var errors = [...]string{
- ErrorNonspecific: "Non-specific error",
- ErrorVersion: "Wrong version",
- ErrorFail: "Failed",
- ErrorNi: "Not Implemented",
- ErrorNomem: "No memory",
- ErrorInval: "Invalid argument",
- ErrorBadfail: "Bad Fail",
- ErrorGuestTimedout: "Guest timed out",
- ErrorTimedout: "Timed out",
- ErrorNoparavirt: "No Paravirtualization",
- ErrorNotReady: "Not ready",
- ErrorOseventRegFail: "OS event registration failed",
- ErrorBufferfull: "Buffer full",
- ErrorUnknownChild: "Unknown child",
- ErrorLockFail: "Lock failed",
- ErrorJsonConfigEmpty: "JSON config empty",
- ErrorDeviceExists: "Device exists",
- ErrorCheckpointDevopsDoesNotMatch: "Checkpoint devops does not match",
- ErrorCheckpointDeviceNotSupported: "Checkpoint device not supported",
- ErrorVnumaConfigInvalid: "VNUMA config invalid",
- ErrorDomainNotfound: "Domain not found",
- ErrorAborted: "Aborted",
- ErrorNotfound: "Not found",
- ErrorDomainDestroyed: "Domain destroyed",
- ErrorFeatureRemoved: "Feature removed",
+var libxlErrors = [...]string{
+ -ErrorNonspecific: "Non-specific error",
+ -ErrorVersion: "Wrong version",
+ -ErrorFail: "Failed",
+ -ErrorNi: "Not Implemented",
+ -ErrorNomem: "No memory",
+ -ErrorInval: "Invalid argument",
+ -ErrorBadfail: "Bad Fail",
+ -ErrorGuestTimedout: "Guest timed out",
+ -ErrorTimedout: "Timed out",
+ -ErrorNoparavirt: "No Paravirtualization",
+ -ErrorNotReady: "Not ready",
+ -ErrorOseventRegFail: "OS event registration failed",
+ -ErrorBufferfull: "Buffer full",
+ -ErrorUnknownChild: "Unknown child",
+ -ErrorLockFail: "Lock failed",
+ -ErrorJsonConfigEmpty: "JSON config empty",
+ -ErrorDeviceExists: "Device exists",
+ -ErrorCheckpointDevopsDoesNotMatch: "Checkpoint devops does not match",
+ -ErrorCheckpointDeviceNotSupported: "Checkpoint device not supported",
+ -ErrorVnumaConfigInvalid: "VNUMA config invalid",
+ -ErrorDomainNotfound: "Domain not found",
+ -ErrorAborted: "Aborted",
+ -ErrorNotfound: "Not found",
+ -ErrorDomainDestroyed: "Domain destroyed",
+ -ErrorFeatureRemoved: "Feature removed",
}
func (e Error) Error() string {
- if 0 < int(e) && int(e) < len(errors) {
- s := errors[e]
+ if 0 < int(e) && int(e) < len(libxlErrors) {
+ s := libxlErrors[e]
if s != "" {
return s
}
}
return fmt.Sprintf("libxl error: %d", -e)
-
}
/*
@@ -236,18 +201,6 @@ func (cinfo *C.libxl_version_info) toGo() (info *VersionInfo) {
return
}
-type ShutdownReason int32
-
-const (
- ShutdownReasonUnknown = ShutdownReason(C.LIBXL_SHUTDOWN_REASON_UNKNOWN)
- ShutdownReasonPoweroff = ShutdownReason(C.LIBXL_SHUTDOWN_REASON_POWEROFF)
- ShutdownReasonReboot = ShutdownReason(C.LIBXL_SHUTDOWN_REASON_REBOOT)
- ShutdownReasonSuspend = ShutdownReason(C.LIBXL_SHUTDOWN_REASON_SUSPEND)
- ShutdownReasonCrash = ShutdownReason(C.LIBXL_SHUTDOWN_REASON_CRASH)
- ShutdownReasonWatchdog = ShutdownReason(C.LIBXL_SHUTDOWN_REASON_WATCHDOG)
- ShutdownReasonSoftReset = ShutdownReason(C.LIBXL_SHUTDOWN_REASON_SOFT_RESET)
-)
-
func (sr ShutdownReason) String() (str string) {
cstr := C.libxl_shutdown_reason_to_string(C.libxl_shutdown_reason(sr))
str = C.GoString(cstr)
@@ -255,14 +208,6 @@ func (sr ShutdownReason) String() (str string) {
return
}
-type DomainType int32
-
-const (
- DomainTypeInvalid = DomainType(C.LIBXL_DOMAIN_TYPE_INVALID)
- DomainTypeHvm = DomainType(C.LIBXL_DOMAIN_TYPE_HVM)
- DomainTypePv = DomainType(C.LIBXL_DOMAIN_TYPE_PV)
-)
-
func (dt DomainType) String() (str string) {
cstr := C.libxl_domain_type_to_string(C.libxl_domain_type(dt))
str = C.GoString(cstr)
@@ -323,27 +268,6 @@ func (cdi *C.libxl_dominfo) toGo() (di *Dominfo) {
return
}
-// # Consistent with values defined in domctl.h
-// # Except unknown which we have made up
-// libxl_scheduler = Enumeration("scheduler", [
-// (0, "unknown"),
-// (4, "sedf"),
-// (5, "credit"),
-// (6, "credit2"),
-// (7, "arinc653"),
-// (8, "rtds"),
-// ])
-type Scheduler int
-
-var (
- SchedulerUnknown Scheduler = C.LIBXL_SCHEDULER_UNKNOWN
- SchedulerSedf Scheduler = C.LIBXL_SCHEDULER_SEDF
- SchedulerCredit Scheduler = C.LIBXL_SCHEDULER_CREDIT
- SchedulerCredit2 Scheduler = C.LIBXL_SCHEDULER_CREDIT2
- SchedulerArinc653 Scheduler = C.LIBXL_SCHEDULER_ARINC653
- SchedulerRTDS Scheduler = C.LIBXL_SCHEDULER_RTDS
-)
-
// const char *libxl_scheduler_to_string(libxl_scheduler p);
func (s Scheduler) String() string {
cs := C.libxl_scheduler_to_string(C.libxl_scheduler(s))
@@ -1141,14 +1065,6 @@ func (Ctx *Context) ListVcpu(id Domid) (glist []Vcpuinfo) {
return
}
-type ConsoleType int
-
-const (
- ConsoleTypeUnknown = ConsoleType(C.LIBXL_CONSOLE_TYPE_UNKNOWN)
- ConsoleTypeSerial = ConsoleType(C.LIBXL_CONSOLE_TYPE_SERIAL)
- ConsoleTypePV = ConsoleType(C.LIBXL_CONSOLE_TYPE_PV)
-)
-
func (ct ConsoleType) String() (str string) {
cstr := C.libxl_console_type_to_string(C.libxl_console_type(ct))
str = C.GoString(cstr)
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* Re: [Xen-devel] [PATCH v3 01/22] golang/xenlight: generate enum types from IDL
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 01/22] golang/xenlight: generate enum types from IDL Nick Rosbrook
@ 2019-12-16 17:07 ` George Dunlap
2019-12-16 17:50 ` Nick Rosbrook
0 siblings, 1 reply; 33+ messages in thread
From: George Dunlap @ 2019-12-16 17:07 UTC (permalink / raw)
To: Nick Rosbrook, xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, Wei Liu
On 12/10/19 3:47 PM, Nick Rosbrook wrote:
> From: Nick Rosbrook <rosbrookn@ainfosec.com>
>
> Introduce gengotypes.py to generate Go code the from IDL. As a first step,
> implement 'enum' type generation.
>
> As a result of the newly-generated code, remove the existing, and now
> conflicting definitions in xenlight.go. In the case of the Error type,
> rename the slice 'errors' to 'libxlErrors' so that it does not conflict
> with the standard library package 'errors.' And, negate the values used
> in 'libxlErrors' since the generated error values are negative.
>
> Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
> Reviewed-by: George Dunlap <george.dunlap@citrix.com>
> ---
> Changes in v2:
> - Introduce Makefile targets for code generation
> - Re-generate Go code (includes new libxl_passtrhough enum).
> - Use *.gen.go naming convention for generated Go files.
> ---
> tools/golang/xenlight/Makefile | 18 +-
> tools/golang/xenlight/gengotypes.py | 109 ++++++++
> tools/golang/xenlight/types.gen.go | 388 ++++++++++++++++++++++++++++
> tools/golang/xenlight/xenlight.go | 140 ++--------
> 4 files changed, 535 insertions(+), 120 deletions(-)
> create mode 100644 tools/golang/xenlight/gengotypes.py
> create mode 100644 tools/golang/xenlight/types.gen.go
>
> diff --git a/tools/golang/xenlight/Makefile b/tools/golang/xenlight/Makefile
> index 0987305224..681f32c234 100644
> --- a/tools/golang/xenlight/Makefile
> +++ b/tools/golang/xenlight/Makefile
> @@ -7,20 +7,21 @@ GOCODE_DIR ?= $(prefix)/share/gocode/
> GOXL_PKG_DIR = /src/$(XEN_GOCODE_URL)/xenlight/
> GOXL_INSTALL_DIR = $(GOCODE_DIR)$(GOXL_PKG_DIR)
>
> -# PKGSOURCES: Files which comprise the distributed source package
> -PKGSOURCES = xenlight.go
> -
> GO ?= go
>
> .PHONY: all
> all: build
>
> .PHONY: package
> -package: $(XEN_GOPATH)$(GOXL_PKG_DIR)$(PKGSOURCES)
> +package: $(XEN_GOPATH)$(GOXL_PKG_DIR)
>
> -$(XEN_GOPATH)/src/$(XEN_GOCODE_URL)/xenlight/$(PKGSOURCES): $(PKGSOURCES)
> +$(XEN_GOPATH)/src/$(XEN_GOCODE_URL)/xenlight/: %.gen.go
I was expecting you to change this if you sent a v3. :-)
I can still change it on check-in, but if for some reason there's a v4,
please make the change before resending. Thanks. :-)
-George
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 33+ messages in thread
* [Xen-devel] [PATCH v3 02/22] golang/xenlight: define Defbool builtin type
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 01/22] golang/xenlight: generate enum types from IDL Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 03/22] golang/xenlight: define Devid type as int Nick Rosbrook
` (19 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Define Defbool as struct analagous to the C type, and define the type
'defboolVal' that represent true, false, and default defbool values.
Implement Set, Unset, SetIfDefault, IsDefault, Val, and String functions
on Defbool so that the type can be used in Go analagously to how its
used in C.
Finally, implement fromC and toC functions.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
tools/golang/xenlight/xenlight.go | 93 +++++++++++++++++++++++++++++++
1 file changed, 93 insertions(+)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 89ed439fd0..640d82f35f 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -85,6 +85,99 @@ type MemKB uint64
type Uuid C.libxl_uuid
+// defboolVal represents a defbool value.
+type defboolVal int
+
+const (
+ defboolDefault defboolVal = 0
+ defboolFalse defboolVal = -1
+ defboolTrue defboolVal = 1
+)
+
+// Defbool represents a libxl_defbool.
+type Defbool struct {
+ val defboolVal
+}
+
+func (d Defbool) String() string {
+ switch d.val {
+ case defboolDefault:
+ return "<default>"
+ case defboolFalse:
+ return "False"
+ case defboolTrue:
+ return "True"
+ }
+
+ return ""
+}
+
+// Set sets the value of the Defbool.
+func (d *Defbool) Set(b bool) {
+ if b {
+ d.val = defboolTrue
+ return
+ }
+ d.val = defboolFalse
+}
+
+// Unset resets the Defbool to default value.
+func (d *Defbool) Unset() {
+ d.val = defboolDefault
+}
+
+// SetIfDefault sets the value of Defbool only if
+// its current value is default.
+func (d *Defbool) SetIfDefault(b bool) {
+ if d.IsDefault() {
+ d.Set(b)
+ }
+}
+
+// IsDefault returns true if the value of Defbool
+// is default, returns false otherwise.
+func (d *Defbool) IsDefault() bool {
+ return d.val == defboolDefault
+}
+
+// Val returns the boolean value associated with the
+// Defbool value. An error is returned if the value
+// is default.
+func (d *Defbool) Val() (bool, error) {
+ if d.IsDefault() {
+ return false, fmt.Errorf("%v: cannot take value of default defbool", ErrorInval)
+ }
+
+ return (d.val > 0), nil
+}
+
+func (d *Defbool) fromC(c *C.libxl_defbool) error {
+ if C.libxl_defbool_is_default(*c) {
+ d.val = defboolDefault
+ return nil
+ }
+
+ if C.libxl_defbool_val(*c) {
+ d.val = defboolTrue
+ return nil
+ }
+
+ d.val = defboolFalse
+
+ return nil
+}
+
+func (d *Defbool) toC() (C.libxl_defbool, error) {
+ var c C.libxl_defbool
+
+ if !d.IsDefault() {
+ val, _ := d.Val()
+ C.libxl_defbool_set(&c, C.bool(val))
+ }
+
+ return c, nil
+}
+
type Context struct {
ctx *C.libxl_ctx
logger *C.xentoollog_logger_stdiostream
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 03/22] golang/xenlight: define Devid type as int
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 01/22] golang/xenlight: generate enum types from IDL Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 02/22] golang/xenlight: define Defbool builtin type Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 04/22] golang/xenlight: define KeyValueList as empty struct Nick Rosbrook
` (18 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
tools/golang/xenlight/xenlight.go | 3 +++
1 file changed, 3 insertions(+)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 640d82f35f..8ac26e63f0 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -81,6 +81,9 @@ func (e Error) Error() string {
type Domid uint32
+// Devid is a device ID.
+type Devid int
+
type MemKB uint64
type Uuid C.libxl_uuid
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 04/22] golang/xenlight: define KeyValueList as empty struct
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (2 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 03/22] golang/xenlight: define Devid type as int Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 05/22] golang/xenlight: re-name Bitmap marshaling functions Nick Rosbrook
` (17 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Define KeyValueList as empty struct as there is currently no reason for
this type to be available in the Go package.
Implement fromC and toC functions as no-ops.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
Changes in v2:
- Re-define KeyValueList as empty struct, as it was decided this type
probably shouldn't be exposed in the Go package.
---
tools/golang/xenlight/xenlight.go | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 8ac26e63f0..3edff18471 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -202,6 +202,16 @@ func (chwcap C.libxl_hwcap) toGo() (ghwcap Hwcap) {
return
}
+// KeyValueList represents a libxl_key_value_list.
+//
+// Represented as an empty struct for now, as there is no
+// apparent need for this type to be exposed through the
+// Go package.
+type KeyValueList struct{}
+
+func (kvl KeyValueList) fromC(ckvl *C.libxl_key_value_list) error { return nil }
+func (kvl KeyValueList) toC() (ckvl C.libxl_key_value_list, err error) { return }
+
// typedef struct {
// uint32_t size; /* number of bytes in map */
// uint8_t *map;
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 05/22] golang/xenlight: re-name Bitmap marshaling functions
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (3 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 04/22] golang/xenlight: define KeyValueList as empty struct Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 06/22] golang/xenlight: define StringList builtin type Nick Rosbrook
` (16 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Re-name and modify signature of toGo function to fromC. The reason for
using 'fromC' rather than 'toGo' is that it is not a good idea to define
methods on the C types. Also, add error return type to Bitmap's toC function.
Finally, as code-cleanup, re-organize the Bitmap type's comments as per
Go conventions.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Acked-by: George Dunlap <george.dunlap@citrix.com>
--
Changes in v2:
- Use consistent variable naming for slice created from
libxl_bitmap.
---
tools/golang/xenlight/xenlight.go | 94 ++++++++++++++++---------------
1 file changed, 48 insertions(+), 46 deletions(-)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 3edff18471..1c5e3c0cc7 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -212,20 +212,48 @@ type KeyValueList struct{}
func (kvl KeyValueList) fromC(ckvl *C.libxl_key_value_list) error { return nil }
func (kvl KeyValueList) toC() (ckvl C.libxl_key_value_list, err error) { return }
-// typedef struct {
-// uint32_t size; /* number of bytes in map */
-// uint8_t *map;
-// } libxl_bitmap;
-
+// Bitmap represents a libxl_bitmap.
+//
// Implement the Go bitmap type such that the underlying data can
// easily be copied in and out. NB that we still have to do copies
// both directions, because cgo runtime restrictions forbid passing to
// a C function a pointer to a Go-allocated structure which contains a
// pointer.
type Bitmap struct {
+ // typedef struct {
+ // uint32_t size; /* number of bytes in map */
+ // uint8_t *map;
+ // } libxl_bitmap;
bitmap []C.uint8_t
}
+func (bm *Bitmap) fromC(cbm *C.libxl_bitmap) error {
+ // Alloc a Go slice for the bytes
+ size := int(cbm.size)
+ bm.bitmap = make([]C.uint8_t, size)
+
+ // Make a slice pointing to the C array
+ cs := (*[1 << 30]C.uint8_t)(unsafe.Pointer(cbm._map))[:size:size]
+
+ // And copy the C array into the Go array
+ copy(bm.bitmap, cs)
+
+ return nil
+}
+
+func (bm *Bitmap) toC() (C.libxl_bitmap, error) {
+ var cbm C.libxl_bitmap
+
+ size := len(bm.bitmap)
+ cbm.size = C.uint32_t(size)
+ cbm._map = (*C.uint8_t)(C.malloc(C.ulong(cbm.size) * C.sizeof_uint8_t))
+ cs := (*[1 << 31]C.uint8_t)(unsafe.Pointer(cbm._map))[:size:size]
+
+ copy(cs, bm.bitmap)
+
+ return cbm, nil
+}
+
/*
* Types: IDL
*
@@ -426,7 +454,7 @@ func (cci C.libxl_cpupoolinfo) toGo() (gci CpupoolInfo) {
gci.PoolName = C.GoString(cci.pool_name)
gci.Scheduler = Scheduler(cci.sched)
gci.DomainCount = int(cci.n_dom)
- gci.Cpumap = cci.cpumap.toGo()
+ gci.Cpumap.fromC(&cci.cpumap)
return
}
@@ -500,7 +528,10 @@ func (Ctx *Context) CpupoolCreate(Name string, Scheduler Scheduler, Cpumap Bitma
var uuid C.libxl_uuid
C.libxl_uuid_generate(&uuid)
- cbm := Cpumap.toC()
+ cbm, err := Cpumap.toC()
+ if err != nil {
+ return
+ }
defer C.libxl_bitmap_dispose(&cbm)
ret := C.libxl_cpupool_create(Ctx.ctx, name, C.libxl_scheduler(Scheduler),
@@ -555,7 +586,10 @@ func (Ctx *Context) CpupoolCpuaddCpumap(Poolid uint32, Cpumap Bitmap) (err error
return
}
- cbm := Cpumap.toC()
+ cbm, err := Cpumap.toC()
+ if err != nil {
+ return
+ }
defer C.libxl_bitmap_dispose(&cbm)
ret := C.libxl_cpupool_cpuadd_cpumap(Ctx.ctx, C.uint32_t(Poolid), &cbm)
@@ -591,7 +625,10 @@ func (Ctx *Context) CpupoolCpuremoveCpumap(Poolid uint32, Cpumap Bitmap) (err er
return
}
- cbm := Cpumap.toC()
+ cbm, err := Cpumap.toC()
+ if err != nil {
+ return
+ }
defer C.libxl_bitmap_dispose(&cbm)
ret := C.libxl_cpupool_cpuremove_cpumap(Ctx.ctx, C.uint32_t(Poolid), &cbm)
@@ -714,41 +751,6 @@ func (Ctx *Context) CpupoolMakeFree(Cpumap Bitmap) (err error) {
* Bitmap operations
*/
-// Return a Go bitmap which is a copy of the referred C bitmap.
-func (cbm C.libxl_bitmap) toGo() (gbm Bitmap) {
- // Alloc a Go slice for the bytes
- size := int(cbm.size)
- gbm.bitmap = make([]C.uint8_t, size)
-
- // Make a slice pointing to the C array
- mapslice := (*[1 << 30]C.uint8_t)(unsafe.Pointer(cbm._map))[:size:size]
-
- // And copy the C array into the Go array
- copy(gbm.bitmap, mapslice)
-
- return
-}
-
-// Must be C.libxl_bitmap_dispose'd of afterwards
-func (gbm Bitmap) toC() (cbm C.libxl_bitmap) {
- C.libxl_bitmap_init(&cbm)
-
- size := len(gbm.bitmap)
- cbm._map = (*C.uint8_t)(C.malloc(C.size_t(size)))
- cbm.size = C.uint32_t(size)
- if cbm._map == nil {
- panic("C.calloc failed!")
- }
-
- // Make a slice pointing to the C array
- mapslice := (*[1 << 30]C.uint8_t)(unsafe.Pointer(cbm._map))[:size:size]
-
- // And copy the Go array into the C array
- copy(mapslice, gbm.bitmap)
-
- return
-}
-
func (bm *Bitmap) Test(bit int) bool {
ubit := uint(bit)
if bit > bm.Max() || bm.bitmap == nil {
@@ -1137,8 +1139,8 @@ func (cvci C.libxl_vcpuinfo) toGo() (gvci Vcpuinfo) {
gvci.Blocked = bool(cvci.blocked)
gvci.Running = bool(cvci.running)
gvci.VCpuTime = time.Duration(cvci.vcpu_time)
- gvci.Cpumap = cvci.cpumap.toGo()
- gvci.CpumapSoft = cvci.cpumap_soft.toGo()
+ gvci.Cpumap.fromC(&cvci.cpumap)
+ gvci.CpumapSoft.fromC(&cvci.cpumap_soft)
return
}
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 06/22] golang/xenlight: define StringList builtin type
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (4 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 05/22] golang/xenlight: re-name Bitmap marshaling functions Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 07/22] golang/xenlight: define Mac " Nick Rosbrook
` (15 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Define StringList as []string an implement fromC and toC functions.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
Changes in v2:
- Define fromC with a pointer receiver since a newly-allocated slice
is being assigned to the StringList.
---
tools/golang/xenlight/xenlight.go | 29 +++++++++++++++++++++++++++++
1 file changed, 29 insertions(+)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 1c5e3c0cc7..72afc3cf14 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -212,6 +212,35 @@ type KeyValueList struct{}
func (kvl KeyValueList) fromC(ckvl *C.libxl_key_value_list) error { return nil }
func (kvl KeyValueList) toC() (ckvl C.libxl_key_value_list, err error) { return }
+// StringList represents a libxl_string_list.
+type StringList []string
+
+func (sl *StringList) fromC(csl *C.libxl_string_list) error {
+ size := int(C.libxl_string_list_length(csl))
+ list := (*[1 << 30]*C.char)(unsafe.Pointer(csl))[:size:size]
+
+ *sl = make([]string, size)
+
+ for i, v := range list {
+ (*sl)[i] = C.GoString(v)
+ }
+
+ return nil
+}
+
+func (sl StringList) toC() (C.libxl_string_list, error) {
+ var char *C.char
+ size := len(sl)
+ csl := (C.libxl_string_list)(C.malloc(C.ulong(size) * C.ulong(unsafe.Sizeof(char))))
+ clist := (*[1 << 30]*C.char)(unsafe.Pointer(csl))[:size:size]
+
+ for i, v := range sl {
+ clist[i] = C.CString(v)
+ }
+
+ return csl, nil
+}
+
// Bitmap represents a libxl_bitmap.
//
// Implement the Go bitmap type such that the underlying data can
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 07/22] golang/xenlight: define Mac builtin type
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (5 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 06/22] golang/xenlight: define StringList builtin type Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-16 17:15 ` George Dunlap
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 08/22] golang/xenlight: define MsVmGenid " Nick Rosbrook
` (14 subsequent siblings)
21 siblings, 1 reply; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Define Mac as [6]byte and implement fromC, toC, and String functions.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
Changes in v2:
- Fix the format string in String function to use %02x.
- Use a value reciever for the toC function.
Changes in v3:
- Iterate over the indirect of mac instead of creating
a slice from the C type.
---
tools/golang/xenlight/xenlight.go | 33 +++++++++++++++++++++++++++++++
1 file changed, 33 insertions(+)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 72afc3cf14..17d146771e 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -181,6 +181,39 @@ func (d *Defbool) toC() (C.libxl_defbool, error) {
return c, nil
}
+// Mac represents a libxl_mac, or simply a MAC address.
+type Mac [6]byte
+
+// String formats a Mac address to string representation.
+func (mac Mac) String() string {
+ s := "%02x:%02x:%02x:%02x:%02x:%02x"
+ opts := make([]interface{}, 6)
+
+ for i, v := range mac {
+ opts[i] = v
+ }
+
+ return fmt.Sprintf(s, opts...)
+}
+
+func (mac *Mac) fromC(cmac *C.libxl_mac) error {
+ for i := range *mac {
+ mac[i] = byte(cmac[i])
+ }
+
+ return nil
+}
+
+func (mac Mac) toC() (C.libxl_mac, error) {
+ var cmac C.libxl_mac
+
+ for i, v := range mac {
+ cmac[i] = C.uint8_t(v)
+ }
+
+ return cmac, nil
+}
+
type Context struct {
ctx *C.libxl_ctx
logger *C.xentoollog_logger_stdiostream
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* Re: [Xen-devel] [PATCH v3 07/22] golang/xenlight: define Mac builtin type
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 07/22] golang/xenlight: define Mac " Nick Rosbrook
@ 2019-12-16 17:15 ` George Dunlap
0 siblings, 0 replies; 33+ messages in thread
From: George Dunlap @ 2019-12-16 17:15 UTC (permalink / raw)
To: Nick Rosbrook, xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, Wei Liu
On 12/10/19 3:47 PM, Nick Rosbrook wrote:
> From: Nick Rosbrook <rosbrookn@ainfosec.com>
>
> Define Mac as [6]byte and implement fromC, toC, and String functions.
>
> Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
> Reviewed-by: George Dunlap <george.dunlap@citrix.com>
> ---
> Changes in v2:
> - Fix the format string in String function to use %02x.
> - Use a value reciever for the toC function.
> Changes in v3:
> - Iterate over the indirect of mac instead of creating
> a slice from the C type.
> ---
> tools/golang/xenlight/xenlight.go | 33 +++++++++++++++++++++++++++++++
> 1 file changed, 33 insertions(+)
>
> diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
> index 72afc3cf14..17d146771e 100644
> --- a/tools/golang/xenlight/xenlight.go
> +++ b/tools/golang/xenlight/xenlight.go
> @@ -181,6 +181,39 @@ func (d *Defbool) toC() (C.libxl_defbool, error) {
> return c, nil
> }
>
> +// Mac represents a libxl_mac, or simply a MAC address.
> +type Mac [6]byte
> +
> +// String formats a Mac address to string representation.
> +func (mac Mac) String() string {
> + s := "%02x:%02x:%02x:%02x:%02x:%02x"
> + opts := make([]interface{}, 6)
> +
> + for i, v := range mac {
> + opts[i] = v
> + }
> +
> + return fmt.Sprintf(s, opts...)
> +}
> +
> +func (mac *Mac) fromC(cmac *C.libxl_mac) error {
> + for i := range *mac {
> + mac[i] = byte(cmac[i])
> + }
That's much better, thanks.
-George
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 33+ messages in thread
* [Xen-devel] [PATCH v3 08/22] golang/xenlight: define MsVmGenid builtin type
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (6 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 07/22] golang/xenlight: define Mac " Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 09/22] golang/xenlight: define EvLink builtin as empty struct Nick Rosbrook
` (13 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Define MsVmGenid as [int(C.LIBXL_MS_VM_GENID_LEN)]byte and implement fromC and toC functions.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
Changes in v3:
- In fromC, iterate over the indirect of mvg instead of creating
a slice from the C type.
---
tools/golang/xenlight/xenlight.go | 21 +++++++++++++++++++++
1 file changed, 21 insertions(+)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 17d146771e..6c3868cd69 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -214,6 +214,27 @@ func (mac Mac) toC() (C.libxl_mac, error) {
return cmac, nil
}
+// MsVmGenid represents a libxl_ms_vm_genid.
+type MsVmGenid [int(C.LIBXL_MS_VM_GENID_LEN)]byte
+
+func (mvg *MsVmGenid) fromC(cmvg *C.libxl_ms_vm_genid) error {
+ for i := range *mvg {
+ mvg[i] = byte(cmvg.bytes[i])
+ }
+
+ return nil
+}
+
+func (mvg *MsVmGenid) toC() (C.libxl_ms_vm_genid, error) {
+ var cmvg C.libxl_ms_vm_genid
+
+ for i, v := range mvg {
+ cmvg.bytes[i] = C.uint8_t(v)
+ }
+
+ return cmvg, nil
+}
+
type Context struct {
ctx *C.libxl_ctx
logger *C.xentoollog_logger_stdiostream
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 09/22] golang/xenlight: define EvLink builtin as empty struct
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (7 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 08/22] golang/xenlight: define MsVmGenid " Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 10/22] golang/xenlight: define CpuidPolicyList builtin type Nick Rosbrook
` (12 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Define EvLink as empty struct as there is currently no reason the internal of
this type should be used in Go.
Implement fromC and toC functions as no-ops.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
tools/golang/xenlight/xenlight.go | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 6c3868cd69..c1d9fe85fd 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -235,6 +235,16 @@ func (mvg *MsVmGenid) toC() (C.libxl_ms_vm_genid, error) {
return cmvg, nil
}
+// EvLink represents a libxl_ev_link.
+//
+// Represented as an empty struct for now, as there is no
+// apparent need for the internals of this type to be exposed
+// through the Go package.
+type EvLink struct{}
+
+func (el *EvLink) fromC(cel *C.libxl_ev_link) error { return nil }
+func (el *EvLink) toC() (cel C.libxl_ev_link, err error) { return }
+
type Context struct {
ctx *C.libxl_ctx
logger *C.xentoollog_logger_stdiostream
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 10/22] golang/xenlight: define CpuidPolicyList builtin type
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (8 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 09/22] golang/xenlight: define EvLink builtin as empty struct Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 11/22] golang/xenlight: re-factor Uuid type implementation Nick Rosbrook
` (11 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Define CpuidPolicyList as a string so that libxl_cpuid_parse_config can
be used in the toC function.
For now, fromC is a no-op since libxl does not support a way to read a
policy, modify it,and then give it back to libxl.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
Changes in v2:
- Re-define CpuidPolicyList as string.
- Make fromC a no-op.
- Use libxl_cpuid_parse_config in toC function.
---
tools/golang/xenlight/xenlight.go | 25 +++++++++++++++++++++++++
1 file changed, 25 insertions(+)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index c1d9fe85fd..6b87bf857d 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -245,6 +245,31 @@ type EvLink struct{}
func (el *EvLink) fromC(cel *C.libxl_ev_link) error { return nil }
func (el *EvLink) toC() (cel C.libxl_ev_link, err error) { return }
+// CpuidPolicyList represents a libxl_cpuid_policy_list.
+//
+// The value of CpuidPolicyList is honored when used as input to libxl. If
+// a struct contains a field of type CpuidPolicyList, that field will be left
+// empty when it is returned from libxl.
+type CpuidPolicyList string
+
+func (cpl CpuidPolicyList) fromC(ccpl *C.libxl_cpuid_policy_list) error { return nil }
+
+func (cpl CpuidPolicyList) toC() (C.libxl_cpuid_policy_list, error) {
+ var ccpl C.libxl_cpuid_policy_list
+
+ s := C.CString(string(cpl))
+ defer C.free(unsafe.Pointer(s))
+
+ ret := C.libxl_cpuid_parse_config(&ccpl, s)
+ if ret != 0 {
+ C.libxl_cpuid_dispose(&ccpl)
+
+ return ccpl, Error(-ret)
+ }
+
+ return ccpl, nil
+}
+
type Context struct {
ctx *C.libxl_ctx
logger *C.xentoollog_logger_stdiostream
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 11/22] golang/xenlight: re-factor Uuid type implementation
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (9 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 10/22] golang/xenlight: define CpuidPolicyList builtin type Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-16 18:06 ` George Dunlap
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 12/22] golang/xenlight: re-factor Hwcap " Nick Rosbrook
` (10 subsequent siblings)
21 siblings, 1 reply; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Re-define Uuid as [16]byte and implement fromC, toC, and String functions.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
Changes in v3:
- In fromC, iterate over the indirect of u instead of creating a
slice from the C type.
---
tools/golang/xenlight/xenlight.go | 35 +++++++++++++++++++++++++++++--
1 file changed, 33 insertions(+), 2 deletions(-)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 6b87bf857d..f9c2f84c81 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -86,7 +86,38 @@ type Devid int
type MemKB uint64
-type Uuid C.libxl_uuid
+// Uuid is a domain UUID.
+type Uuid [16]byte
+
+// String formats a Uuid in the form "xxxx-xx-xx-xx-xxxxxx".
+func (u Uuid) String() string {
+ s := "%x%x%x%x-%x%x-%x%x-%x%x-%x%x%x%x%x%x"
+ opts := make([]interface{}, 16)
+
+ for i, v := range u {
+ opts[i] = v
+ }
+
+ return fmt.Sprintf(s, opts...)
+}
+
+func (u *Uuid) fromC(c *C.libxl_uuid) error {
+ for i := range *u {
+ u[i] = byte(c.uuid[i])
+ }
+
+ return nil
+}
+
+func (u *Uuid) toC() (C.libxl_uuid, error) {
+ var c C.libxl_uuid
+
+ for i, v := range u {
+ c.uuid[i] = C.uint8_t(v)
+ }
+
+ return c, nil
+}
// defboolVal represents a defbool value.
type defboolVal int
@@ -495,7 +526,7 @@ type Dominfo struct {
func (cdi *C.libxl_dominfo) toGo() (di *Dominfo) {
di = &Dominfo{}
- di.Uuid = Uuid(cdi.uuid)
+ di.Uuid.fromC(&cdi.uuid)
di.Domid = Domid(cdi.domid)
di.Ssidref = uint32(cdi.ssidref)
di.SsidLabel = C.GoString(cdi.ssid_label)
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 12/22] golang/xenlight: re-factor Hwcap type implementation
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (10 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 11/22] golang/xenlight: re-factor Uuid type implementation Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 13/22] golang/xenlight: generate structs from the IDL Nick Rosbrook
` (9 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Re-define Hwcap as [8]uint32, and implement toC function. Also, re-name and
modify signature of toGo function to fromC.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
Changes in v2:
- Fix comment in fromC since an array is being used now, not a slice.
- Use a concise variable name instead of mapslice for the C array.
Changes in v3:
- In fromC, iterate over the indirect of hwcap instead of creating
a slice from the C type.
---
tools/golang/xenlight/xenlight.go | 27 ++++++++++++++++-----------
1 file changed, 16 insertions(+), 11 deletions(-)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index f9c2f84c81..b395963512 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -306,20 +306,25 @@ type Context struct {
logger *C.xentoollog_logger_stdiostream
}
-type Hwcap []C.uint32_t
+// Hwcap represents a libxl_hwcap.
+type Hwcap [8]uint32
-func (chwcap C.libxl_hwcap) toGo() (ghwcap Hwcap) {
- // Alloc a Go slice for the bytes
- size := 8
- ghwcap = make([]C.uint32_t, size)
+func (hwcap *Hwcap) fromC(chwcap *C.libxl_hwcap) error {
+ for i := range *hwcap {
+ hwcap[i] = uint32(chwcap[i])
+ }
- // Make a slice pointing to the C array
- mapslice := (*[1 << 30]C.uint32_t)(unsafe.Pointer(&chwcap[0]))[:size:size]
+ return nil
+}
- // And copy the C array into the Go array
- copy(ghwcap, mapslice)
+func (hwcap *Hwcap) toC() (C.libxl_hwcap, error) {
+ var chwcap C.libxl_hwcap
- return
+ for i, v := range hwcap {
+ chwcap[i] = C.uint32_t(v)
+ }
+
+ return chwcap, nil
}
// KeyValueList represents a libxl_key_value_list.
@@ -442,7 +447,7 @@ func (cphys *C.libxl_physinfo) toGo() (physinfo *Physinfo) {
physinfo.SharingFreedPages = uint64(cphys.sharing_freed_pages)
physinfo.SharingUsedFrames = uint64(cphys.sharing_used_frames)
physinfo.NrNodes = uint32(cphys.nr_nodes)
- physinfo.HwCap = cphys.hw_cap.toGo()
+ physinfo.HwCap.fromC(&cphys.hw_cap)
physinfo.CapHvm = bool(cphys.cap_hvm)
physinfo.CapHvmDirectio = bool(cphys.cap_hvm_directio)
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 13/22] golang/xenlight: generate structs from the IDL
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (11 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 12/22] golang/xenlight: re-factor Hwcap " Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 14/22] golang/xenlight: remove no-longer used type MemKB Nick Rosbrook
` (8 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Add struct and keyed union generation to gengotypes.py. For keyed unions,
use a method similar to gRPC's oneof to interpret C unions as Go types.
Meaning, for a given struct with a union field, generate a struct for
each sub-struct defined in the union. Then, define an interface of one
method which is implemented by each of the defined sub-structs. For
example:
type domainBuildInfoTypeUnion interface {
isdomainBuildInfoTypeUnion()
}
type DomainBuildInfoTypeUnionHvm struct {
// HVM-specific fields...
}
func (x DomainBuildInfoTypeUnionHvm) isdomainBuildInfoTypeUnion() {}
type DomainBuildInfoTypeUnionPv struct {
// PV-specific fields...
}
func (x DomainBuildInfoTypeUnionPv) isdomainBuildInfoTypeUnion() {}
type DomainBuildInfoTypeUnionPvh struct {
// PVH-specific fields...
}
func (x DomainBuildInfoTypeUnionPvh) isdomainBuildInfoTypeUnion() {}
Then, remove existing struct definitions in xenlight.go that conflict
with the generated types, and modify existing marshaling functions to
align with the new type definitions. Notably, drop "time" package since
fields of type time.Duration are now of type uint64.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
---
Changes in v2:
- Do not use global variables for extra type definitions. Instead,
return a tuple which includes a list of extra type definitions
associated with the original type.
- Re-generate types.gen.go to include changes to libxl after rebase.
---
tools/golang/xenlight/gengotypes.py | 119 +++-
tools/golang/xenlight/types.gen.go | 836 ++++++++++++++++++++++++++++
tools/golang/xenlight/xenlight.go | 123 +---
3 files changed, 966 insertions(+), 112 deletions(-)
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
index 2211541547..8963b14eee 100644
--- a/tools/golang/xenlight/gengotypes.py
+++ b/tools/golang/xenlight/gengotypes.py
@@ -32,18 +32,32 @@ def xenlight_golang_generate_types(path = None, types = None, comment = None):
f.write('package xenlight\n')
for ty in types:
- f.write(xenlight_golang_type_define(ty))
+ (tdef, extras) = xenlight_golang_type_define(ty)
+
+ f.write(tdef)
f.write('\n')
+ # Append extra types
+ for extra in extras:
+ f.write(extra)
+ f.write('\n')
+
go_fmt(path)
def xenlight_golang_type_define(ty = None):
- s = ''
+ """
+ Generate the Go type definition of ty.
+ Return a tuple that contains a string with the
+ type definition, and a (potentially empty) list
+ of extra definitions that are associated with
+ this type.
+ """
if isinstance(ty, idl.Enumeration):
- s += xenlight_golang_define_enum(ty)
+ return (xenlight_golang_define_enum(ty), [])
- return s
+ elif isinstance(ty, idl.Aggregate):
+ return xenlight_golang_define_struct(ty)
def xenlight_golang_define_enum(ty = None):
s = ''
@@ -65,6 +79,103 @@ def xenlight_golang_define_enum(ty = None):
return s
+def xenlight_golang_define_struct(ty = None, typename = None, nested = False):
+ s = ''
+ extras = []
+ name = ''
+
+ if typename is not None:
+ name = xenlight_golang_fmt_name(typename)
+ else:
+ name = xenlight_golang_fmt_name(ty.typename)
+
+ # Begin struct definition
+ if nested:
+ s += '{} struct {{\n'.format(name)
+ else:
+ s += 'type {} struct {{\n'.format(name)
+
+ # Write struct fields
+ for f in ty.fields:
+ if f.type.typename is not None:
+ if isinstance(f.type, idl.Array):
+ typename = f.type.elem_type.typename
+ typename = xenlight_golang_fmt_name(typename)
+ name = xenlight_golang_fmt_name(f.name)
+
+ s += '{} []{}\n'.format(name, typename)
+ else:
+ typename = f.type.typename
+ typename = xenlight_golang_fmt_name(typename)
+ name = xenlight_golang_fmt_name(f.name)
+
+ s += '{} {}\n'.format(name, typename)
+
+ elif isinstance(f.type, idl.Struct):
+ r = xenlight_golang_define_struct(f.type, typename=f.name, nested=True)
+
+ s += r[0]
+ extras.extend(r[1])
+
+ elif isinstance(f.type, idl.KeyedUnion):
+ r = xenlight_golang_define_union(f.type, ty.typename)
+
+ s += r[0]
+ extras.extend(r[1])
+
+ else:
+ raise Exception('type {} not supported'.format(f.type))
+
+ # End struct definition
+ s += '}\n'
+
+ return (s,extras)
+
+def xenlight_golang_define_union(ty = None, structname = ''):
+ """
+ Generate the Go translation of a KeyedUnion.
+
+ Define an unexported interface to be used as
+ the type of the union. Then, define a struct
+ for each field of the union which implements
+ that interface.
+ """
+ s = ''
+ extras = []
+
+ interface_name = '{}_{}_union'.format(structname, ty.keyvar.name)
+ interface_name = xenlight_golang_fmt_name(interface_name, exported=False)
+
+ s += 'type {} interface {{\n'.format(interface_name)
+ s += 'is{}()\n'.format(interface_name)
+ s += '}\n'
+
+ extras.append(s)
+
+ for f in ty.fields:
+ if f.type is None:
+ continue
+
+ # Define struct
+ name = '{}_{}_union_{}'.format(structname, ty.keyvar.name, f.name)
+ r = xenlight_golang_define_struct(f.type, typename=name)
+ extras.append(r[0])
+ extras.extend(r[1])
+
+ # Define function to implement 'union' interface
+ name = xenlight_golang_fmt_name(name)
+ s = 'func (x {}) is{}(){{}}\n'.format(name, interface_name)
+ extras.append(s)
+
+ fname = xenlight_golang_fmt_name(ty.keyvar.name)
+ ftype = xenlight_golang_fmt_name(ty.keyvar.type.typename)
+ s = '{} {}\n'.format(fname, ftype)
+
+ fname = xenlight_golang_fmt_name('{}_union'.format(ty.keyvar.name))
+ s += '{} {}\n'.format(fname, interface_name)
+
+ return (s,extras)
+
def xenlight_golang_fmt_name(name, exported = True):
"""
Take a given type name and return an
diff --git a/tools/golang/xenlight/types.gen.go b/tools/golang/xenlight/types.gen.go
index 4a52eab048..ede49b4886 100644
--- a/tools/golang/xenlight/types.gen.go
+++ b/tools/golang/xenlight/types.gen.go
@@ -275,6 +275,183 @@ const (
PassthroughSharePt Passthrough = 4
)
+type IoportRange struct {
+ First uint32
+ Number uint32
+}
+
+type IomemRange struct {
+ Start uint64
+ Number uint64
+ Gfn uint64
+}
+
+type VgaInterfaceInfo struct {
+ Kind VgaInterfaceType
+}
+
+type VncInfo struct {
+ Enable Defbool
+ Listen string
+ Passwd string
+ Display int
+ Findunused Defbool
+}
+
+type SpiceInfo struct {
+ Enable Defbool
+ Port int
+ TlsPort int
+ Host string
+ DisableTicketing Defbool
+ Passwd string
+ AgentMouse Defbool
+ Vdagent Defbool
+ ClipboardSharing Defbool
+ Usbredirection int
+ ImageCompression string
+ StreamingVideo string
+}
+
+type SdlInfo struct {
+ Enable Defbool
+ Opengl Defbool
+ Display string
+ Xauthority string
+}
+
+type Dominfo struct {
+ Uuid Uuid
+ Domid Domid
+ Ssidref uint32
+ SsidLabel string
+ Running bool
+ Blocked bool
+ Paused bool
+ Shutdown bool
+ Dying bool
+ NeverStop bool
+ ShutdownReason ShutdownReason
+ OutstandingMemkb uint64
+ CurrentMemkb uint64
+ SharedMemkb uint64
+ PagedMemkb uint64
+ MaxMemkb uint64
+ CpuTime uint64
+ VcpuMaxId uint32
+ VcpuOnline uint32
+ Cpupool uint32
+ DomainType DomainType
+}
+
+type Cpupoolinfo struct {
+ Poolid uint32
+ PoolName string
+ Sched Scheduler
+ NDom uint32
+ Cpumap Bitmap
+}
+
+type Channelinfo struct {
+ Backend string
+ BackendId uint32
+ Frontend string
+ FrontendId uint32
+ Devid Devid
+ State int
+ Evtch int
+ Rref int
+ Connection ChannelConnection
+ ConnectionUnion channelinfoConnectionUnion
+}
+
+type channelinfoConnectionUnion interface {
+ ischannelinfoConnectionUnion()
+}
+
+type ChannelinfoConnectionUnionPty struct {
+ Path string
+}
+
+func (x ChannelinfoConnectionUnionPty) ischannelinfoConnectionUnion() {}
+
+type Vminfo struct {
+ Uuid Uuid
+ Domid Domid
+}
+
+type VersionInfo struct {
+ XenVersionMajor int
+ XenVersionMinor int
+ XenVersionExtra string
+ Compiler string
+ CompileBy string
+ CompileDomain string
+ CompileDate string
+ Capabilities string
+ Changeset string
+ VirtStart uint64
+ Pagesize int
+ Commandline string
+ BuildId string
+}
+
+type DomainCreateInfo struct {
+ Type DomainType
+ Hap Defbool
+ Oos Defbool
+ Ssidref uint32
+ SsidLabel string
+ Name string
+ Uuid Uuid
+ Xsdata KeyValueList
+ Platformdata KeyValueList
+ Poolid uint32
+ PoolName string
+ RunHotplugScripts Defbool
+ DriverDomain Defbool
+ Passthrough Passthrough
+}
+
+type DomainRestoreParams struct {
+ CheckpointedStream int
+ StreamVersion uint32
+ ColoProxyScript string
+ UserspaceColoProxy Defbool
+}
+
+type SchedParams struct {
+ Vcpuid int
+ Weight int
+ Cap int
+ Period int
+ Extratime int
+ Budget int
+}
+
+type VcpuSchedParams struct {
+ Sched Scheduler
+ Vcpus []SchedParams
+}
+
+type DomainSchedParams struct {
+ Sched Scheduler
+ Weight int
+ Cap int
+ Period int
+ Budget int
+ Extratime int
+ Slice int
+ Latency int
+}
+
+type VnodeInfo struct {
+ Memkb uint64
+ Distances []uint32
+ Pnode uint32
+ Vcpus Bitmap
+}
+
type GicVersion int
const (
@@ -290,6 +467,11 @@ const (
TeeTypeOptee TeeType = 1
)
+type RdmReserve struct {
+ Strategy RdmReserveStrategy
+ Policy RdmReservePolicy
+}
+
type Altp2MMode int
const (
@@ -299,6 +481,278 @@ const (
Altp2MModeLimited Altp2MMode = 3
)
+type DomainBuildInfo struct {
+ MaxVcpus int
+ AvailVcpus Bitmap
+ Cpumap Bitmap
+ Nodemap Bitmap
+ VcpuHardAffinity []Bitmap
+ VcpuSoftAffinity []Bitmap
+ NumaPlacement Defbool
+ TscMode TscMode
+ MaxMemkb uint64
+ TargetMemkb uint64
+ VideoMemkb uint64
+ ShadowMemkb uint64
+ IommuMemkb uint64
+ RtcTimeoffset uint32
+ ExecSsidref uint32
+ ExecSsidLabel string
+ Localtime Defbool
+ DisableMigrate Defbool
+ Cpuid CpuidPolicyList
+ BlkdevStart string
+ VnumaNodes []VnodeInfo
+ MaxGrantFrames uint32
+ MaxMaptrackFrames uint32
+ DeviceModelVersion DeviceModelVersion
+ DeviceModelStubdomain Defbool
+ DeviceModel string
+ DeviceModelSsidref uint32
+ DeviceModelSsidLabel string
+ DeviceModelUser string
+ Extra StringList
+ ExtraPv StringList
+ ExtraHvm StringList
+ SchedParams DomainSchedParams
+ Ioports []IoportRange
+ Irqs []uint32
+ Iomem []IomemRange
+ ClaimMode Defbool
+ EventChannels uint32
+ Kernel string
+ Cmdline string
+ Ramdisk string
+ DeviceTree string
+ Acpi Defbool
+ Bootloader string
+ BootloaderArgs StringList
+ TimerMode TimerMode
+ NestedHvm Defbool
+ Apic Defbool
+ DmRestrict Defbool
+ Tee TeeType
+ Type DomainType
+ TypeUnion domainBuildInfoTypeUnion
+ ArchArm struct {
+ GicVersion GicVersion
+ Vuart VuartType
+ }
+ Altp2M Altp2MMode
+}
+
+type domainBuildInfoTypeUnion interface {
+ isdomainBuildInfoTypeUnion()
+}
+
+type DomainBuildInfoTypeUnionHvm struct {
+ Firmware string
+ Bios BiosType
+ Pae Defbool
+ Apic Defbool
+ Acpi Defbool
+ AcpiS3 Defbool
+ AcpiS4 Defbool
+ AcpiLaptopSlate Defbool
+ Nx Defbool
+ Viridian Defbool
+ ViridianEnable Bitmap
+ ViridianDisable Bitmap
+ Timeoffset string
+ Hpet Defbool
+ VptAlign Defbool
+ MmioHoleMemkb uint64
+ TimerMode TimerMode
+ NestedHvm Defbool
+ Altp2M Defbool
+ SystemFirmware string
+ SmbiosFirmware string
+ AcpiFirmware string
+ Hdtype Hdtype
+ Nographic Defbool
+ Vga VgaInterfaceInfo
+ Vnc VncInfo
+ Keymap string
+ Sdl SdlInfo
+ Spice SpiceInfo
+ GfxPassthru Defbool
+ GfxPassthruKind GfxPassthruKind
+ Serial string
+ Boot string
+ Usb Defbool
+ Usbversion int
+ Usbdevice string
+ VkbDevice Defbool
+ Soundhw string
+ XenPlatformPci Defbool
+ UsbdeviceList StringList
+ VendorDevice VendorDevice
+ MsVmGenid MsVmGenid
+ SerialList StringList
+ Rdm RdmReserve
+ RdmMemBoundaryMemkb uint64
+ McaCaps uint64
+}
+
+func (x DomainBuildInfoTypeUnionHvm) isdomainBuildInfoTypeUnion() {}
+
+type DomainBuildInfoTypeUnionPv struct {
+ Kernel string
+ SlackMemkb uint64
+ Bootloader string
+ BootloaderArgs StringList
+ Cmdline string
+ Ramdisk string
+ Features string
+ E820Host Defbool
+}
+
+func (x DomainBuildInfoTypeUnionPv) isdomainBuildInfoTypeUnion() {}
+
+type DomainBuildInfoTypeUnionPvh struct {
+ Pvshim Defbool
+ PvshimPath string
+ PvshimCmdline string
+ PvshimExtra string
+}
+
+func (x DomainBuildInfoTypeUnionPvh) isdomainBuildInfoTypeUnion() {}
+
+type DeviceVfb struct {
+ BackendDomid Domid
+ BackendDomname string
+ Devid Devid
+ Vnc VncInfo
+ Sdl SdlInfo
+ Keymap string
+}
+
+type DeviceVkb struct {
+ BackendDomid Domid
+ BackendDomname string
+ Devid Devid
+ BackendType VkbBackend
+ UniqueId string
+ FeatureDisableKeyboard bool
+ FeatureDisablePointer bool
+ FeatureAbsPointer bool
+ FeatureRawPointer bool
+ FeatureMultiTouch bool
+ Width uint32
+ Height uint32
+ MultiTouchWidth uint32
+ MultiTouchHeight uint32
+ MultiTouchNumContacts uint32
+}
+
+type DeviceDisk struct {
+ BackendDomid Domid
+ BackendDomname string
+ PdevPath string
+ Vdev string
+ Backend DiskBackend
+ Format DiskFormat
+ Script string
+ Removable int
+ Readwrite int
+ IsCdrom int
+ DirectIoSafe bool
+ DiscardEnable Defbool
+ ColoEnable Defbool
+ ColoRestoreEnable Defbool
+ ColoHost string
+ ColoPort int
+ ColoExport string
+ ActiveDisk string
+ HiddenDisk string
+}
+
+type DeviceNic struct {
+ BackendDomid Domid
+ BackendDomname string
+ Devid Devid
+ Mtu int
+ Model string
+ Mac Mac
+ Ip string
+ Bridge string
+ Ifname string
+ Script string
+ Nictype NicType
+ RateBytesPerInterval uint64
+ RateIntervalUsecs uint32
+ Gatewaydev string
+ ColoftForwarddev string
+ ColoSockMirrorId string
+ ColoSockMirrorIp string
+ ColoSockMirrorPort string
+ ColoSockComparePriInId string
+ ColoSockComparePriInIp string
+ ColoSockComparePriInPort string
+ ColoSockCompareSecInId string
+ ColoSockCompareSecInIp string
+ ColoSockCompareSecInPort string
+ ColoSockCompareNotifyId string
+ ColoSockCompareNotifyIp string
+ ColoSockCompareNotifyPort string
+ ColoSockRedirector0Id string
+ ColoSockRedirector0Ip string
+ ColoSockRedirector0Port string
+ ColoSockRedirector1Id string
+ ColoSockRedirector1Ip string
+ ColoSockRedirector1Port string
+ ColoSockRedirector2Id string
+ ColoSockRedirector2Ip string
+ ColoSockRedirector2Port string
+ ColoFilterMirrorQueue string
+ ColoFilterMirrorOutdev string
+ ColoFilterRedirector0Queue string
+ ColoFilterRedirector0Indev string
+ ColoFilterRedirector0Outdev string
+ ColoFilterRedirector1Queue string
+ ColoFilterRedirector1Indev string
+ ColoFilterRedirector1Outdev string
+ ColoComparePriIn string
+ ColoCompareSecIn string
+ ColoCompareOut string
+ ColoCompareNotifyDev string
+ ColoSockSecRedirector0Id string
+ ColoSockSecRedirector0Ip string
+ ColoSockSecRedirector0Port string
+ ColoSockSecRedirector1Id string
+ ColoSockSecRedirector1Ip string
+ ColoSockSecRedirector1Port string
+ ColoFilterSecRedirector0Queue string
+ ColoFilterSecRedirector0Indev string
+ ColoFilterSecRedirector0Outdev string
+ ColoFilterSecRedirector1Queue string
+ ColoFilterSecRedirector1Indev string
+ ColoFilterSecRedirector1Outdev string
+ ColoFilterSecRewriter0Queue string
+ ColoCheckpointHost string
+ ColoCheckpointPort string
+}
+
+type DevicePci struct {
+ Func byte
+ Dev byte
+ Bus byte
+ Domain int
+ Vdevfn uint32
+ VfuncMask uint32
+ Msitranslate bool
+ PowerMgmt bool
+ Permissive bool
+ Seize bool
+ RdmPolicy RdmReservePolicy
+}
+
+type DeviceRdm struct {
+ Start uint64
+ Size uint64
+ Policy RdmReservePolicy
+}
+
type UsbctrlType int
const (
@@ -314,6 +768,92 @@ const (
UsbdevTypeHostdev UsbdevType = 1
)
+type DeviceUsbctrl struct {
+ Type UsbctrlType
+ Devid Devid
+ Version int
+ Ports int
+ BackendDomid Domid
+ BackendDomname string
+}
+
+type DeviceUsbdev struct {
+ Ctrl Devid
+ Port int
+ Type UsbdevType
+ TypeUnion deviceUsbdevTypeUnion
+}
+
+type deviceUsbdevTypeUnion interface {
+ isdeviceUsbdevTypeUnion()
+}
+
+type DeviceUsbdevTypeUnionHostdev struct {
+ Hostbus byte
+ Hostaddr byte
+}
+
+func (x DeviceUsbdevTypeUnionHostdev) isdeviceUsbdevTypeUnion() {}
+
+type DeviceDtdev struct {
+ Path string
+}
+
+type DeviceVtpm struct {
+ BackendDomid Domid
+ BackendDomname string
+ Devid Devid
+ Uuid Uuid
+}
+
+type DeviceP9 struct {
+ BackendDomid Domid
+ BackendDomname string
+ Tag string
+ Path string
+ SecurityModel string
+ Devid Devid
+}
+
+type DevicePvcallsif struct {
+ BackendDomid Domid
+ BackendDomname string
+ Devid Devid
+}
+
+type DeviceChannel struct {
+ BackendDomid Domid
+ BackendDomname string
+ Devid Devid
+ Name string
+ Connection ChannelConnection
+ ConnectionUnion deviceChannelConnectionUnion
+}
+
+type deviceChannelConnectionUnion interface {
+ isdeviceChannelConnectionUnion()
+}
+
+type DeviceChannelConnectionUnionSocket struct {
+ Path string
+}
+
+func (x DeviceChannelConnectionUnionSocket) isdeviceChannelConnectionUnion() {}
+
+type ConnectorParam struct {
+ UniqueId string
+ Width uint32
+ Height uint32
+}
+
+type DeviceVdispl struct {
+ BackendDomid Domid
+ BackendDomname string
+ Devid Devid
+ BeAlloc bool
+ Connectors []ConnectorParam
+}
+
type VsndPcmFormat int
const (
@@ -344,6 +884,14 @@ const (
VsndPcmFormatGsm VsndPcmFormat = 25
)
+type VsndParams struct {
+ SampleRates []uint32
+ SampleFormats []VsndPcmFormat
+ ChannelsMin uint32
+ ChannelsMax uint32
+ BufferSize uint32
+}
+
type VsndStreamType int
const (
@@ -351,6 +899,229 @@ const (
VsndStreamTypeC VsndStreamType = 2
)
+type VsndStream struct {
+ UniqueId string
+ Type VsndStreamType
+ Params VsndParams
+}
+
+type VsndPcm struct {
+ Name string
+ Params VsndParams
+ Streams []VsndStream
+}
+
+type DeviceVsnd struct {
+ BackendDomid Domid
+ BackendDomname string
+ Devid Devid
+ ShortName string
+ LongName string
+ Params VsndParams
+ Pcms []VsndPcm
+}
+
+type DomainConfig struct {
+ CInfo DomainCreateInfo
+ BInfo DomainBuildInfo
+ Disks []DeviceDisk
+ Nics []DeviceNic
+ Pcidevs []DevicePci
+ Rdms []DeviceRdm
+ Dtdevs []DeviceDtdev
+ Vfbs []DeviceVfb
+ Vkbs []DeviceVkb
+ Vtpms []DeviceVtpm
+ P9S []DeviceP9
+ Pvcallsifs []DevicePvcallsif
+ Vdispls []DeviceVdispl
+ Vsnds []DeviceVsnd
+ Channels []DeviceChannel
+ Usbctrls []DeviceUsbctrl
+ Usbdevs []DeviceUsbdev
+ OnPoweroff ActionOnShutdown
+ OnReboot ActionOnShutdown
+ OnWatchdog ActionOnShutdown
+ OnCrash ActionOnShutdown
+ OnSoftReset ActionOnShutdown
+}
+
+type Diskinfo struct {
+ Backend string
+ BackendId uint32
+ Frontend string
+ FrontendId uint32
+ Devid Devid
+ State int
+ Evtch int
+ Rref int
+}
+
+type Nicinfo struct {
+ Backend string
+ BackendId uint32
+ Frontend string
+ FrontendId uint32
+ Devid Devid
+ State int
+ Evtch int
+ RrefTx int
+ RrefRx int
+}
+
+type Vtpminfo struct {
+ Backend string
+ BackendId uint32
+ Frontend string
+ FrontendId uint32
+ Devid Devid
+ State int
+ Evtch int
+ Rref int
+ Uuid Uuid
+}
+
+type Usbctrlinfo struct {
+ Type UsbctrlType
+ Devid Devid
+ Version int
+ Ports int
+ Backend string
+ BackendId uint32
+ Frontend string
+ FrontendId uint32
+ State int
+ Evtch int
+ RefUrb int
+ RefConn int
+}
+
+type Vcpuinfo struct {
+ Vcpuid uint32
+ Cpu uint32
+ Online bool
+ Blocked bool
+ Running bool
+ VcpuTime uint64
+ Cpumap Bitmap
+ CpumapSoft Bitmap
+}
+
+type Physinfo struct {
+ ThreadsPerCore uint32
+ CoresPerSocket uint32
+ MaxCpuId uint32
+ NrCpus uint32
+ CpuKhz uint32
+ TotalPages uint64
+ FreePages uint64
+ ScrubPages uint64
+ OutstandingPages uint64
+ SharingFreedPages uint64
+ SharingUsedFrames uint64
+ MaxPossibleMfn uint64
+ NrNodes uint32
+ HwCap Hwcap
+ CapHvm bool
+ CapPv bool
+ CapHvmDirectio bool
+ CapHap bool
+ CapShadow bool
+ CapIommuHapPtShare bool
+}
+
+type Connectorinfo struct {
+ UniqueId string
+ Width uint32
+ Height uint32
+ ReqEvtch int
+ ReqRref int
+ EvtEvtch int
+ EvtRref int
+}
+
+type Vdisplinfo struct {
+ Backend string
+ BackendId uint32
+ Frontend string
+ FrontendId uint32
+ Devid Devid
+ State int
+ BeAlloc bool
+ Connectors []Connectorinfo
+}
+
+type Streaminfo struct {
+ ReqEvtch int
+ ReqRref int
+}
+
+type Pcminfo struct {
+ Streams []Streaminfo
+}
+
+type Vsndinfo struct {
+ Backend string
+ BackendId uint32
+ Frontend string
+ FrontendId uint32
+ Devid Devid
+ State int
+ Pcms []Pcminfo
+}
+
+type Vkbinfo struct {
+ Backend string
+ BackendId uint32
+ Frontend string
+ FrontendId uint32
+ Devid Devid
+ State int
+ Evtch int
+ Rref int
+}
+
+type Numainfo struct {
+ Size uint64
+ Free uint64
+ Dists []uint32
+}
+
+type Cputopology struct {
+ Core uint32
+ Socket uint32
+ Node uint32
+}
+
+type Pcitopology struct {
+ Seg uint16
+ Bus byte
+ Devfn byte
+ Node uint32
+}
+
+type SchedCreditParams struct {
+ TsliceMs int
+ RatelimitUs int
+ VcpuMigrDelayUs int
+}
+
+type SchedCredit2Params struct {
+ RatelimitUs int
+}
+
+type DomainRemusInfo struct {
+ Interval int
+ AllowUnsafe Defbool
+ Blackhole Defbool
+ Compression Defbool
+ Netbuf Defbool
+ Netbufscript string
+ Diskbuf Defbool
+ Colo Defbool
+ UserspaceColoProxy Defbool
+}
+
type EventType int
const (
@@ -361,6 +1132,38 @@ const (
EventTypeDomainCreateConsoleAvailable EventType = 5
)
+type Event struct {
+ Link EvLink
+ Domid Domid
+ Domuuid Uuid
+ ForUser uint64
+ Type EventType
+ TypeUnion eventTypeUnion
+}
+
+type eventTypeUnion interface {
+ iseventTypeUnion()
+}
+
+type EventTypeUnionDomainShutdown struct {
+ ShutdownReason byte
+}
+
+func (x EventTypeUnionDomainShutdown) iseventTypeUnion() {}
+
+type EventTypeUnionDiskEject struct {
+ Vdev string
+ Disk DeviceDisk
+}
+
+func (x EventTypeUnionDiskEject) iseventTypeUnion() {}
+
+type EventTypeUnionOperationComplete struct {
+ Rc int
+}
+
+func (x EventTypeUnionOperationComplete) iseventTypeUnion() {}
+
type PsrCmtType int
const (
@@ -380,9 +1183,42 @@ const (
PsrCbmTypeMbaThrtl PsrCbmType = 5
)
+type PsrCatInfo struct {
+ Id uint32
+ CosMax uint32
+ CbmLen uint32
+ CdpEnabled bool
+}
+
type PsrFeatType int
const (
PsrFeatTypeCat PsrFeatType = 1
PsrFeatTypeMba PsrFeatType = 2
)
+
+type PsrHwInfo struct {
+ Id uint32
+ Type PsrFeatType
+ TypeUnion psrHwInfoTypeUnion
+}
+
+type psrHwInfoTypeUnion interface {
+ ispsrHwInfoTypeUnion()
+}
+
+type PsrHwInfoTypeUnionCat struct {
+ CosMax uint32
+ CbmLen uint32
+ CdpEnabled bool
+}
+
+func (x PsrHwInfoTypeUnionCat) ispsrHwInfoTypeUnion() {}
+
+type PsrHwInfoTypeUnionMba struct {
+ CosMax uint32
+ ThrtlMax uint32
+ Linear bool
+}
+
+func (x PsrHwInfoTypeUnionMba) ispsrHwInfoTypeUnion() {}
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index b395963512..8f41047726 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -33,7 +33,6 @@ import "C"
import (
"fmt"
- "time"
"unsafe"
)
@@ -408,30 +407,6 @@ func (bm *Bitmap) toC() (C.libxl_bitmap, error) {
return cbm, nil
}
-/*
- * Types: IDL
- *
- * FIXME: Generate these automatically from the IDL
- */
-
-type Physinfo struct {
- ThreadsPerCore uint32
- CoresPerSocket uint32
- MaxCpuId uint32
- NrCpus uint32
- CpuKhz uint32
- TotalPages uint64
- FreePages uint64
- ScrubPages uint64
- OutstandingPages uint64
- SharingFreedPages uint64
- SharingUsedFrames uint64
- NrNodes uint32
- HwCap Hwcap
- CapHvm bool
- CapHvmDirectio bool
-}
-
func (cphys *C.libxl_physinfo) toGo() (physinfo *Physinfo) {
physinfo = &Physinfo{}
@@ -454,22 +429,6 @@ func (cphys *C.libxl_physinfo) toGo() (physinfo *Physinfo) {
return
}
-type VersionInfo struct {
- XenVersionMajor int
- XenVersionMinor int
- XenVersionExtra string
- Compiler string
- CompileBy string
- CompileDomain string
- CompileDate string
- Capabilities string
- Changeset string
- VirtStart uint64
- Pagesize int
- Commandline string
- BuildId string
-}
-
func (cinfo *C.libxl_version_info) toGo() (info *VersionInfo) {
info = &VersionInfo{}
info.XenVersionMajor = int(cinfo.xen_version_major)
@@ -503,31 +462,6 @@ func (dt DomainType) String() (str string) {
return
}
-type Dominfo struct {
- Uuid Uuid
- Domid Domid
- Ssidref uint32
- SsidLabel string
- Running bool
- Blocked bool
- Paused bool
- Shutdown bool
- Dying bool
- NeverStop bool
-
- ShutdownReason int32
- OutstandingMemkb MemKB
- CurrentMemkb MemKB
- SharedMemkb MemKB
- PagedMemkb MemKB
- MaxMemkb MemKB
- CpuTime time.Duration
- VcpuMaxId uint32
- VcpuOnline uint32
- Cpupool uint32
- DomainType int32
-}
-
func (cdi *C.libxl_dominfo) toGo() (di *Dominfo) {
di = &Dominfo{}
@@ -541,17 +475,17 @@ func (cdi *C.libxl_dominfo) toGo() (di *Dominfo) {
di.Shutdown = bool(cdi.shutdown)
di.Dying = bool(cdi.dying)
di.NeverStop = bool(cdi.never_stop)
- di.ShutdownReason = int32(cdi.shutdown_reason)
- di.OutstandingMemkb = MemKB(cdi.outstanding_memkb)
- di.CurrentMemkb = MemKB(cdi.current_memkb)
- di.SharedMemkb = MemKB(cdi.shared_memkb)
- di.PagedMemkb = MemKB(cdi.paged_memkb)
- di.MaxMemkb = MemKB(cdi.max_memkb)
- di.CpuTime = time.Duration(cdi.cpu_time)
+ di.ShutdownReason = ShutdownReason(cdi.shutdown_reason)
+ di.OutstandingMemkb = uint64(cdi.outstanding_memkb)
+ di.CurrentMemkb = uint64(cdi.current_memkb)
+ di.SharedMemkb = uint64(cdi.shared_memkb)
+ di.PagedMemkb = uint64(cdi.paged_memkb)
+ di.MaxMemkb = uint64(cdi.max_memkb)
+ di.CpuTime = uint64(cdi.cpu_time)
di.VcpuMaxId = uint32(cdi.vcpu_max_id)
di.VcpuOnline = uint32(cdi.vcpu_online)
di.Cpupool = uint32(cdi.cpupool)
- di.DomainType = int32(cdi.domain_type)
+ di.DomainType = DomainType(cdi.domain_type)
return
}
@@ -587,27 +521,11 @@ func SchedulerFromString(name string) (s Scheduler, err error) {
return
}
-// libxl_cpupoolinfo = Struct("cpupoolinfo", [
-// ("poolid", uint32),
-// ("pool_name", string),
-// ("sched", libxl_scheduler),
-// ("n_dom", uint32),
-// ("cpumap", libxl_bitmap)
-// ], dir=DIR_OUT)
-
-type CpupoolInfo struct {
- Poolid uint32
- PoolName string
- Scheduler Scheduler
- DomainCount int
- Cpumap Bitmap
-}
-
-func (cci C.libxl_cpupoolinfo) toGo() (gci CpupoolInfo) {
+func (cci C.libxl_cpupoolinfo) toGo() (gci Cpupoolinfo) {
gci.Poolid = uint32(cci.poolid)
gci.PoolName = C.GoString(cci.pool_name)
- gci.Scheduler = Scheduler(cci.sched)
- gci.DomainCount = int(cci.n_dom)
+ gci.Sched = Scheduler(cci.sched)
+ gci.NDom = uint32(cci.n_dom)
gci.Cpumap.fromC(&cci.cpumap)
return
@@ -615,7 +533,7 @@ func (cci C.libxl_cpupoolinfo) toGo() (gci CpupoolInfo) {
// libxl_cpupoolinfo * libxl_list_cpupool(libxl_ctx*, int *nb_pool_out);
// void libxl_cpupoolinfo_list_free(libxl_cpupoolinfo *list, int nb_pool);
-func (Ctx *Context) ListCpupool() (list []CpupoolInfo) {
+func (Ctx *Context) ListCpupool() (list []Cpupoolinfo) {
err := Ctx.CheckOpen()
if err != nil {
return
@@ -642,7 +560,7 @@ func (Ctx *Context) ListCpupool() (list []CpupoolInfo) {
}
// int libxl_cpupool_info(libxl_ctx *ctx, libxl_cpupoolinfo *info, uint32_t poolid);
-func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool CpupoolInfo) {
+func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool Cpupoolinfo) {
err := Ctx.CheckOpen()
if err != nil {
return
@@ -872,7 +790,7 @@ func (Ctx *Context) CpupoolMovedomain(Poolid uint32, Id Domid) (err error) {
//
// Utility functions
//
-func (Ctx *Context) CpupoolFindByName(name string) (info CpupoolInfo, found bool) {
+func (Ctx *Context) CpupoolFindByName(name string) (info Cpupoolinfo, found bool) {
plist := Ctx.ListCpupool()
for i := range plist {
@@ -1275,24 +1193,13 @@ func (Ctx *Context) ListDomain() (glist []Dominfo) {
return
}
-type Vcpuinfo struct {
- Vcpuid uint32
- Cpu uint32
- Online bool
- Blocked bool
- Running bool
- VCpuTime time.Duration
- Cpumap Bitmap
- CpumapSoft Bitmap
-}
-
func (cvci C.libxl_vcpuinfo) toGo() (gvci Vcpuinfo) {
gvci.Vcpuid = uint32(cvci.vcpuid)
gvci.Cpu = uint32(cvci.cpu)
gvci.Online = bool(cvci.online)
gvci.Blocked = bool(cvci.blocked)
gvci.Running = bool(cvci.running)
- gvci.VCpuTime = time.Duration(cvci.vcpu_time)
+ gvci.VcpuTime = uint64(cvci.vcpu_time)
gvci.Cpumap.fromC(&cvci.cpumap)
gvci.CpumapSoft.fromC(&cvci.cpumap_soft)
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 14/22] golang/xenlight: remove no-longer used type MemKB
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (12 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 13/22] golang/xenlight: generate structs from the IDL Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 15/22] golang/xenlight: begin C to Go type marshaling Nick Rosbrook
` (7 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Acked-by: George Dunlap <george.dunlap@citrix.com>
---
tools/golang/xenlight/xenlight.go | 2 --
1 file changed, 2 deletions(-)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 8f41047726..fb1c6d9e51 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -83,8 +83,6 @@ type Domid uint32
// Devid is a device ID.
type Devid int
-type MemKB uint64
-
// Uuid is a domain UUID.
type Uuid [16]byte
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 15/22] golang/xenlight: begin C to Go type marshaling
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (13 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 14/22] golang/xenlight: remove no-longer used type MemKB Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-16 17:56 ` George Dunlap
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 16/22] golang/xenlight: implement keyed union C to Go marshaling Nick Rosbrook
` (6 subsequent siblings)
21 siblings, 1 reply; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Begin implementation of fromC marshaling functions for generated struct
types. This includes support for converting fields that are basic
primitive types such as string and integer types, nested anonymous
structs, nested libxl structs, and libxl built-in types.
This patch does not implement conversion of arrays or keyed unions.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
Changes in v2:
- Add Makefile changes for helpers.gen.go.
- Re-generate helpers.gen.go to include libxl changes after rebase.
Changes in v3:
- Break out field copying/type conversion code into its own function
called xenlight_golang_convert_from_C to allow that code to be easily
re-used.
- Use consistent style for calling fromC on struct fields that require
it. Namely, do not use a temporary variable - call fromC directly on
the struct field.
---
tools/golang/xenlight/Makefile | 2 +
tools/golang/xenlight/gengotypes.py | 118 ++++
tools/golang/xenlight/helpers.gen.go | 901 +++++++++++++++++++++++++++
tools/golang/xenlight/xenlight.go | 111 +---
4 files changed, 1032 insertions(+), 100 deletions(-)
create mode 100644 tools/golang/xenlight/helpers.gen.go
diff --git a/tools/golang/xenlight/Makefile b/tools/golang/xenlight/Makefile
index 681f32c234..07b8896e5b 100644
--- a/tools/golang/xenlight/Makefile
+++ b/tools/golang/xenlight/Makefile
@@ -19,6 +19,7 @@ $(XEN_GOPATH)/src/$(XEN_GOCODE_URL)/xenlight/: %.gen.go
$(INSTALL_DIR) $(XEN_GOPATH)$(GOXL_PKG_DIR)
$(INSTALL_DATA) xenlight.go $(XEN_GOPATH)$(GOXL_PKG_DIR)
$(INSTALL_DATA) types.gen.go $(XEN_GOPATH)$(GOXL_PKG_DIR)
+ $(INSTALL_DATA) helpers.gen.go $(XEN_GOPATH)$(GOXL_PKG_DIR)
%.gen.go: gengotypes.py $(XEN_ROOT)/tools/libxl/libxl_types.idl $(XEN_ROOT)/tools/libxl/idl.py
XEN_ROOT=$(XEN_ROOT) $(PYTHON) gengotypes.py ../../libxl/libxl_types.idl
@@ -39,6 +40,7 @@ install: build
$(INSTALL_DIR) $(DESTDIR)$(GOXL_INSTALL_DIR)
$(INSTALL_DATA) $(XEN_GOPATH)$(GOXL_PKG_DIR)xenlight.go $(DESTDIR)$(GOXL_INSTALL_DIR)
$(INSTALL_DATA) $(XEN_GOPATH)$(GOXL_PKG_DIR)types.gen.go $(DESTDIR)$(GOXL_INSTALL_DIR)
+ $(INSTALL_DATA) $(XEN_GOPATH)$(GOXL_PKG_DIR)helpers.gen.go $(DESTDIR)$(GOXL_INSTALL_DIR)
.PHONY: uninstall
rm -rf $(DESTDIR)$(GOXL_INSTALL_DIR)
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
index 8963b14eee..1fe56179e2 100644
--- a/tools/golang/xenlight/gengotypes.py
+++ b/tools/golang/xenlight/gengotypes.py
@@ -18,6 +18,12 @@ builtin_type_names = {
idl.uint64.typename: 'uint64',
}
+# Some go keywords that conflict with field names in libxl structs.
+go_keywords = ['type', 'func']
+
+go_builtin_types = ['bool', 'string', 'int', 'byte',
+ 'uint16', 'uint32', 'uint64']
+
def xenlight_golang_generate_types(path = None, types = None, comment = None):
"""
Generate a .go file (types.gen.go by default)
@@ -176,6 +182,116 @@ def xenlight_golang_define_union(ty = None, structname = ''):
return (s,extras)
+def xenlight_golang_generate_helpers(path = None, types = None, comment = None):
+ """
+ Generate a .go file (helpers.gen.go by default)
+ that contains helper functions for marshaling between
+ C and Go types.
+ """
+ if path is None:
+ path = 'helpers.gen.go'
+
+ with open(path, 'w') as f:
+ if comment is not None:
+ f.write(comment)
+ f.write('package xenlight\n')
+
+ # Cgo preamble
+ f.write('/*\n')
+ f.write('#cgo LDFLAGS: -lxenlight\n')
+ f.write('#include <stdlib.h>\n')
+ f.write('#include <libxl.h>\n')
+ f.write('\n')
+
+ f.write('*/\nimport "C"\n')
+
+ for ty in types:
+ if not isinstance(ty, idl.Struct):
+ continue
+
+ f.write(xenlight_golang_define_from_C(ty))
+ f.write('\n')
+
+ go_fmt(path)
+
+def xenlight_golang_define_from_C(ty = None):
+ """
+ Define the fromC marshaling function for the type
+ represented by ty.
+ """
+ func = 'func (x *{}) fromC(xc *C.{}) error {{\n {} \n return nil}}\n'
+
+ goname = xenlight_golang_fmt_name(ty.typename)
+ cname = ty.typename
+
+ body = ''
+
+ for f in ty.fields:
+ if f.type.typename is not None:
+ if isinstance(f.type, idl.Array):
+ # TODO
+ continue
+
+ body += xenlight_golang_convert_from_C(f)
+
+ elif isinstance(f.type, idl.Struct):
+ # Go through the fields of the anonymous nested struct.
+ for nf in f.type.fields:
+ body += xenlight_golang_convert_from_C(nf,outer_name=f.name)
+
+ elif isinstance(f.type, idl.KeyedUnion):
+ pass
+
+ else:
+ raise Exception('type {} not supported'.format(f.type))
+
+ return func.format(goname, cname, body)
+
+def xenlight_golang_convert_from_C(ty = None, outer_name = None):
+ """
+ Returns a line of Go code that converts the C type represented
+ by ty to its corresponding Go type.
+
+ If outer_name is set, the type is treated as nested within another field
+ named outer_name.
+ """
+ s = ''
+
+ gotypename = xenlight_golang_fmt_name(ty.type.typename)
+ goname = xenlight_golang_fmt_name(ty.name)
+ cname = ty.name
+
+ # In cgo, C names that conflict with Go keywords can be
+ # accessed by prepending an underscore to the name.
+ if cname in go_keywords:
+ cname = '_' + cname
+
+ # If outer_name is set, treat this as nested.
+ if outer_name is not None:
+ goname = '{}.{}'.format(xenlight_golang_fmt_name(outer_name), goname)
+ cname = '{}.{}'.format(outer_name, cname)
+
+ # Types that satisfy this condition can be easily casted or
+ # converted to a Go builtin type.
+ is_castable = (ty.type.json_parse_type == 'JSON_INTEGER' or
+ isinstance(ty.type, idl.Enumeration) or
+ gotypename in go_builtin_types)
+
+ if not is_castable:
+ # If the type is not castable, we need to call its fromC
+ # function.
+ s += 'if err := x.{}.fromC(&xc.{});'.format(goname,cname)
+ s += 'err != nil {\n return err \n}\n'
+
+ elif gotypename == 'string':
+ # Use the cgo helper for converting C strings.
+ s += 'x.{} = C.GoString(xc.{})\n'.format(goname, cname)
+
+ else:
+ s += 'x.{} = {}(xc.{})\n'.format(goname, gotypename, cname)
+
+ return s
+
def xenlight_golang_fmt_name(name, exported = True):
"""
Take a given type name and return an
@@ -218,3 +334,5 @@ if __name__ == '__main__':
xenlight_golang_generate_types(types=types,
comment=header_comment)
+ xenlight_golang_generate_helpers(types=types,
+ comment=header_comment)
diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go
new file mode 100644
index 0000000000..576aebcf6d
--- /dev/null
+++ b/tools/golang/xenlight/helpers.gen.go
@@ -0,0 +1,901 @@
+// DO NOT EDIT.
+//
+// This file is generated by:
+// gengotypes.py ../../libxl/libxl_types.idl
+//
+package xenlight
+
+/*
+#cgo LDFLAGS: -lxenlight
+#include <stdlib.h>
+#include <libxl.h>
+
+*/
+import "C"
+
+func (x *IoportRange) fromC(xc *C.libxl_ioport_range) error {
+ x.First = uint32(xc.first)
+ x.Number = uint32(xc.number)
+
+ return nil
+}
+
+func (x *IomemRange) fromC(xc *C.libxl_iomem_range) error {
+ x.Start = uint64(xc.start)
+ x.Number = uint64(xc.number)
+ x.Gfn = uint64(xc.gfn)
+
+ return nil
+}
+
+func (x *VgaInterfaceInfo) fromC(xc *C.libxl_vga_interface_info) error {
+ x.Kind = VgaInterfaceType(xc.kind)
+
+ return nil
+}
+
+func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error {
+ if err := x.Enable.fromC(&xc.enable); err != nil {
+ return err
+ }
+ x.Listen = C.GoString(xc.listen)
+ x.Passwd = C.GoString(xc.passwd)
+ x.Display = int(xc.display)
+ if err := x.Findunused.fromC(&xc.findunused); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error {
+ if err := x.Enable.fromC(&xc.enable); err != nil {
+ return err
+ }
+ x.Port = int(xc.port)
+ x.TlsPort = int(xc.tls_port)
+ x.Host = C.GoString(xc.host)
+ if err := x.DisableTicketing.fromC(&xc.disable_ticketing); err != nil {
+ return err
+ }
+ x.Passwd = C.GoString(xc.passwd)
+ if err := x.AgentMouse.fromC(&xc.agent_mouse); err != nil {
+ return err
+ }
+ if err := x.Vdagent.fromC(&xc.vdagent); err != nil {
+ return err
+ }
+ if err := x.ClipboardSharing.fromC(&xc.clipboard_sharing); err != nil {
+ return err
+ }
+ x.Usbredirection = int(xc.usbredirection)
+ x.ImageCompression = C.GoString(xc.image_compression)
+ x.StreamingVideo = C.GoString(xc.streaming_video)
+
+ return nil
+}
+
+func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error {
+ if err := x.Enable.fromC(&xc.enable); err != nil {
+ return err
+ }
+ if err := x.Opengl.fromC(&xc.opengl); err != nil {
+ return err
+ }
+ x.Display = C.GoString(xc.display)
+ x.Xauthority = C.GoString(xc.xauthority)
+
+ return nil
+}
+
+func (x *Dominfo) fromC(xc *C.libxl_dominfo) error {
+ if err := x.Uuid.fromC(&xc.uuid); err != nil {
+ return err
+ }
+ x.Domid = Domid(xc.domid)
+ x.Ssidref = uint32(xc.ssidref)
+ x.SsidLabel = C.GoString(xc.ssid_label)
+ x.Running = bool(xc.running)
+ x.Blocked = bool(xc.blocked)
+ x.Paused = bool(xc.paused)
+ x.Shutdown = bool(xc.shutdown)
+ x.Dying = bool(xc.dying)
+ x.NeverStop = bool(xc.never_stop)
+ x.ShutdownReason = ShutdownReason(xc.shutdown_reason)
+ x.OutstandingMemkb = uint64(xc.outstanding_memkb)
+ x.CurrentMemkb = uint64(xc.current_memkb)
+ x.SharedMemkb = uint64(xc.shared_memkb)
+ x.PagedMemkb = uint64(xc.paged_memkb)
+ x.MaxMemkb = uint64(xc.max_memkb)
+ x.CpuTime = uint64(xc.cpu_time)
+ x.VcpuMaxId = uint32(xc.vcpu_max_id)
+ x.VcpuOnline = uint32(xc.vcpu_online)
+ x.Cpupool = uint32(xc.cpupool)
+ x.DomainType = DomainType(xc.domain_type)
+
+ return nil
+}
+
+func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) error {
+ x.Poolid = uint32(xc.poolid)
+ x.PoolName = C.GoString(xc.pool_name)
+ x.Sched = Scheduler(xc.sched)
+ x.NDom = uint32(xc.n_dom)
+ if err := x.Cpumap.fromC(&xc.cpumap); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *Channelinfo) fromC(xc *C.libxl_channelinfo) error {
+ x.Backend = C.GoString(xc.backend)
+ x.BackendId = uint32(xc.backend_id)
+ x.Frontend = C.GoString(xc.frontend)
+ x.FrontendId = uint32(xc.frontend_id)
+ x.Devid = Devid(xc.devid)
+ x.State = int(xc.state)
+ x.Evtch = int(xc.evtch)
+ x.Rref = int(xc.rref)
+
+ return nil
+}
+
+func (x *Vminfo) fromC(xc *C.libxl_vminfo) error {
+ if err := x.Uuid.fromC(&xc.uuid); err != nil {
+ return err
+ }
+ x.Domid = Domid(xc.domid)
+
+ return nil
+}
+
+func (x *VersionInfo) fromC(xc *C.libxl_version_info) error {
+ x.XenVersionMajor = int(xc.xen_version_major)
+ x.XenVersionMinor = int(xc.xen_version_minor)
+ x.XenVersionExtra = C.GoString(xc.xen_version_extra)
+ x.Compiler = C.GoString(xc.compiler)
+ x.CompileBy = C.GoString(xc.compile_by)
+ x.CompileDomain = C.GoString(xc.compile_domain)
+ x.CompileDate = C.GoString(xc.compile_date)
+ x.Capabilities = C.GoString(xc.capabilities)
+ x.Changeset = C.GoString(xc.changeset)
+ x.VirtStart = uint64(xc.virt_start)
+ x.Pagesize = int(xc.pagesize)
+ x.Commandline = C.GoString(xc.commandline)
+ x.BuildId = C.GoString(xc.build_id)
+
+ return nil
+}
+
+func (x *DomainCreateInfo) fromC(xc *C.libxl_domain_create_info) error {
+ x.Type = DomainType(xc._type)
+ if err := x.Hap.fromC(&xc.hap); err != nil {
+ return err
+ }
+ if err := x.Oos.fromC(&xc.oos); err != nil {
+ return err
+ }
+ x.Ssidref = uint32(xc.ssidref)
+ x.SsidLabel = C.GoString(xc.ssid_label)
+ x.Name = C.GoString(xc.name)
+ if err := x.Uuid.fromC(&xc.uuid); err != nil {
+ return err
+ }
+ if err := x.Xsdata.fromC(&xc.xsdata); err != nil {
+ return err
+ }
+ if err := x.Platformdata.fromC(&xc.platformdata); err != nil {
+ return err
+ }
+ x.Poolid = uint32(xc.poolid)
+ x.PoolName = C.GoString(xc.pool_name)
+ if err := x.RunHotplugScripts.fromC(&xc.run_hotplug_scripts); err != nil {
+ return err
+ }
+ if err := x.DriverDomain.fromC(&xc.driver_domain); err != nil {
+ return err
+ }
+ x.Passthrough = Passthrough(xc.passthrough)
+
+ return nil
+}
+
+func (x *DomainRestoreParams) fromC(xc *C.libxl_domain_restore_params) error {
+ x.CheckpointedStream = int(xc.checkpointed_stream)
+ x.StreamVersion = uint32(xc.stream_version)
+ x.ColoProxyScript = C.GoString(xc.colo_proxy_script)
+ if err := x.UserspaceColoProxy.fromC(&xc.userspace_colo_proxy); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *SchedParams) fromC(xc *C.libxl_sched_params) error {
+ x.Vcpuid = int(xc.vcpuid)
+ x.Weight = int(xc.weight)
+ x.Cap = int(xc.cap)
+ x.Period = int(xc.period)
+ x.Extratime = int(xc.extratime)
+ x.Budget = int(xc.budget)
+
+ return nil
+}
+
+func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
+ x.Sched = Scheduler(xc.sched)
+
+ return nil
+}
+
+func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error {
+ x.Sched = Scheduler(xc.sched)
+ x.Weight = int(xc.weight)
+ x.Cap = int(xc.cap)
+ x.Period = int(xc.period)
+ x.Budget = int(xc.budget)
+ x.Extratime = int(xc.extratime)
+ x.Slice = int(xc.slice)
+ x.Latency = int(xc.latency)
+
+ return nil
+}
+
+func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error {
+ x.Memkb = uint64(xc.memkb)
+ x.Pnode = uint32(xc.pnode)
+ if err := x.Vcpus.fromC(&xc.vcpus); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) error {
+ x.Strategy = RdmReserveStrategy(xc.strategy)
+ x.Policy = RdmReservePolicy(xc.policy)
+
+ return nil
+}
+
+func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error {
+ x.MaxVcpus = int(xc.max_vcpus)
+ if err := x.AvailVcpus.fromC(&xc.avail_vcpus); err != nil {
+ return err
+ }
+ if err := x.Cpumap.fromC(&xc.cpumap); err != nil {
+ return err
+ }
+ if err := x.Nodemap.fromC(&xc.nodemap); err != nil {
+ return err
+ }
+ if err := x.NumaPlacement.fromC(&xc.numa_placement); err != nil {
+ return err
+ }
+ x.TscMode = TscMode(xc.tsc_mode)
+ x.MaxMemkb = uint64(xc.max_memkb)
+ x.TargetMemkb = uint64(xc.target_memkb)
+ x.VideoMemkb = uint64(xc.video_memkb)
+ x.ShadowMemkb = uint64(xc.shadow_memkb)
+ x.IommuMemkb = uint64(xc.iommu_memkb)
+ x.RtcTimeoffset = uint32(xc.rtc_timeoffset)
+ x.ExecSsidref = uint32(xc.exec_ssidref)
+ x.ExecSsidLabel = C.GoString(xc.exec_ssid_label)
+ if err := x.Localtime.fromC(&xc.localtime); err != nil {
+ return err
+ }
+ if err := x.DisableMigrate.fromC(&xc.disable_migrate); err != nil {
+ return err
+ }
+ if err := x.Cpuid.fromC(&xc.cpuid); err != nil {
+ return err
+ }
+ x.BlkdevStart = C.GoString(xc.blkdev_start)
+ x.MaxGrantFrames = uint32(xc.max_grant_frames)
+ x.MaxMaptrackFrames = uint32(xc.max_maptrack_frames)
+ x.DeviceModelVersion = DeviceModelVersion(xc.device_model_version)
+ if err := x.DeviceModelStubdomain.fromC(&xc.device_model_stubdomain); err != nil {
+ return err
+ }
+ x.DeviceModel = C.GoString(xc.device_model)
+ x.DeviceModelSsidref = uint32(xc.device_model_ssidref)
+ x.DeviceModelSsidLabel = C.GoString(xc.device_model_ssid_label)
+ x.DeviceModelUser = C.GoString(xc.device_model_user)
+ if err := x.Extra.fromC(&xc.extra); err != nil {
+ return err
+ }
+ if err := x.ExtraPv.fromC(&xc.extra_pv); err != nil {
+ return err
+ }
+ if err := x.ExtraHvm.fromC(&xc.extra_hvm); err != nil {
+ return err
+ }
+ if err := x.SchedParams.fromC(&xc.sched_params); err != nil {
+ return err
+ }
+ if err := x.ClaimMode.fromC(&xc.claim_mode); err != nil {
+ return err
+ }
+ x.EventChannels = uint32(xc.event_channels)
+ x.Kernel = C.GoString(xc.kernel)
+ x.Cmdline = C.GoString(xc.cmdline)
+ x.Ramdisk = C.GoString(xc.ramdisk)
+ x.DeviceTree = C.GoString(xc.device_tree)
+ if err := x.Acpi.fromC(&xc.acpi); err != nil {
+ return err
+ }
+ x.Bootloader = C.GoString(xc.bootloader)
+ if err := x.BootloaderArgs.fromC(&xc.bootloader_args); err != nil {
+ return err
+ }
+ x.TimerMode = TimerMode(xc.timer_mode)
+ if err := x.NestedHvm.fromC(&xc.nested_hvm); err != nil {
+ return err
+ }
+ if err := x.Apic.fromC(&xc.apic); err != nil {
+ return err
+ }
+ if err := x.DmRestrict.fromC(&xc.dm_restrict); err != nil {
+ return err
+ }
+ x.Tee = TeeType(xc.tee)
+ x.ArchArm.GicVersion = GicVersion(xc.arch_arm.gic_version)
+ x.ArchArm.Vuart = VuartType(xc.arch_arm.vuart)
+ x.Altp2M = Altp2MMode(xc.altp2m)
+
+ return nil
+}
+
+func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) error {
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+ x.Devid = Devid(xc.devid)
+ if err := x.Vnc.fromC(&xc.vnc); err != nil {
+ return err
+ }
+ if err := x.Sdl.fromC(&xc.sdl); err != nil {
+ return err
+ }
+ x.Keymap = C.GoString(xc.keymap)
+
+ return nil
+}
+
+func (x *DeviceVkb) fromC(xc *C.libxl_device_vkb) error {
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+ x.Devid = Devid(xc.devid)
+ x.BackendType = VkbBackend(xc.backend_type)
+ x.UniqueId = C.GoString(xc.unique_id)
+ x.FeatureDisableKeyboard = bool(xc.feature_disable_keyboard)
+ x.FeatureDisablePointer = bool(xc.feature_disable_pointer)
+ x.FeatureAbsPointer = bool(xc.feature_abs_pointer)
+ x.FeatureRawPointer = bool(xc.feature_raw_pointer)
+ x.FeatureMultiTouch = bool(xc.feature_multi_touch)
+ x.Width = uint32(xc.width)
+ x.Height = uint32(xc.height)
+ x.MultiTouchWidth = uint32(xc.multi_touch_width)
+ x.MultiTouchHeight = uint32(xc.multi_touch_height)
+ x.MultiTouchNumContacts = uint32(xc.multi_touch_num_contacts)
+
+ return nil
+}
+
+func (x *DeviceDisk) fromC(xc *C.libxl_device_disk) error {
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+ x.PdevPath = C.GoString(xc.pdev_path)
+ x.Vdev = C.GoString(xc.vdev)
+ x.Backend = DiskBackend(xc.backend)
+ x.Format = DiskFormat(xc.format)
+ x.Script = C.GoString(xc.script)
+ x.Removable = int(xc.removable)
+ x.Readwrite = int(xc.readwrite)
+ x.IsCdrom = int(xc.is_cdrom)
+ x.DirectIoSafe = bool(xc.direct_io_safe)
+ if err := x.DiscardEnable.fromC(&xc.discard_enable); err != nil {
+ return err
+ }
+ if err := x.ColoEnable.fromC(&xc.colo_enable); err != nil {
+ return err
+ }
+ if err := x.ColoRestoreEnable.fromC(&xc.colo_restore_enable); err != nil {
+ return err
+ }
+ x.ColoHost = C.GoString(xc.colo_host)
+ x.ColoPort = int(xc.colo_port)
+ x.ColoExport = C.GoString(xc.colo_export)
+ x.ActiveDisk = C.GoString(xc.active_disk)
+ x.HiddenDisk = C.GoString(xc.hidden_disk)
+
+ return nil
+}
+
+func (x *DeviceNic) fromC(xc *C.libxl_device_nic) error {
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+ x.Devid = Devid(xc.devid)
+ x.Mtu = int(xc.mtu)
+ x.Model = C.GoString(xc.model)
+ if err := x.Mac.fromC(&xc.mac); err != nil {
+ return err
+ }
+ x.Ip = C.GoString(xc.ip)
+ x.Bridge = C.GoString(xc.bridge)
+ x.Ifname = C.GoString(xc.ifname)
+ x.Script = C.GoString(xc.script)
+ x.Nictype = NicType(xc.nictype)
+ x.RateBytesPerInterval = uint64(xc.rate_bytes_per_interval)
+ x.RateIntervalUsecs = uint32(xc.rate_interval_usecs)
+ x.Gatewaydev = C.GoString(xc.gatewaydev)
+ x.ColoftForwarddev = C.GoString(xc.coloft_forwarddev)
+ x.ColoSockMirrorId = C.GoString(xc.colo_sock_mirror_id)
+ x.ColoSockMirrorIp = C.GoString(xc.colo_sock_mirror_ip)
+ x.ColoSockMirrorPort = C.GoString(xc.colo_sock_mirror_port)
+ x.ColoSockComparePriInId = C.GoString(xc.colo_sock_compare_pri_in_id)
+ x.ColoSockComparePriInIp = C.GoString(xc.colo_sock_compare_pri_in_ip)
+ x.ColoSockComparePriInPort = C.GoString(xc.colo_sock_compare_pri_in_port)
+ x.ColoSockCompareSecInId = C.GoString(xc.colo_sock_compare_sec_in_id)
+ x.ColoSockCompareSecInIp = C.GoString(xc.colo_sock_compare_sec_in_ip)
+ x.ColoSockCompareSecInPort = C.GoString(xc.colo_sock_compare_sec_in_port)
+ x.ColoSockCompareNotifyId = C.GoString(xc.colo_sock_compare_notify_id)
+ x.ColoSockCompareNotifyIp = C.GoString(xc.colo_sock_compare_notify_ip)
+ x.ColoSockCompareNotifyPort = C.GoString(xc.colo_sock_compare_notify_port)
+ x.ColoSockRedirector0Id = C.GoString(xc.colo_sock_redirector0_id)
+ x.ColoSockRedirector0Ip = C.GoString(xc.colo_sock_redirector0_ip)
+ x.ColoSockRedirector0Port = C.GoString(xc.colo_sock_redirector0_port)
+ x.ColoSockRedirector1Id = C.GoString(xc.colo_sock_redirector1_id)
+ x.ColoSockRedirector1Ip = C.GoString(xc.colo_sock_redirector1_ip)
+ x.ColoSockRedirector1Port = C.GoString(xc.colo_sock_redirector1_port)
+ x.ColoSockRedirector2Id = C.GoString(xc.colo_sock_redirector2_id)
+ x.ColoSockRedirector2Ip = C.GoString(xc.colo_sock_redirector2_ip)
+ x.ColoSockRedirector2Port = C.GoString(xc.colo_sock_redirector2_port)
+ x.ColoFilterMirrorQueue = C.GoString(xc.colo_filter_mirror_queue)
+ x.ColoFilterMirrorOutdev = C.GoString(xc.colo_filter_mirror_outdev)
+ x.ColoFilterRedirector0Queue = C.GoString(xc.colo_filter_redirector0_queue)
+ x.ColoFilterRedirector0Indev = C.GoString(xc.colo_filter_redirector0_indev)
+ x.ColoFilterRedirector0Outdev = C.GoString(xc.colo_filter_redirector0_outdev)
+ x.ColoFilterRedirector1Queue = C.GoString(xc.colo_filter_redirector1_queue)
+ x.ColoFilterRedirector1Indev = C.GoString(xc.colo_filter_redirector1_indev)
+ x.ColoFilterRedirector1Outdev = C.GoString(xc.colo_filter_redirector1_outdev)
+ x.ColoComparePriIn = C.GoString(xc.colo_compare_pri_in)
+ x.ColoCompareSecIn = C.GoString(xc.colo_compare_sec_in)
+ x.ColoCompareOut = C.GoString(xc.colo_compare_out)
+ x.ColoCompareNotifyDev = C.GoString(xc.colo_compare_notify_dev)
+ x.ColoSockSecRedirector0Id = C.GoString(xc.colo_sock_sec_redirector0_id)
+ x.ColoSockSecRedirector0Ip = C.GoString(xc.colo_sock_sec_redirector0_ip)
+ x.ColoSockSecRedirector0Port = C.GoString(xc.colo_sock_sec_redirector0_port)
+ x.ColoSockSecRedirector1Id = C.GoString(xc.colo_sock_sec_redirector1_id)
+ x.ColoSockSecRedirector1Ip = C.GoString(xc.colo_sock_sec_redirector1_ip)
+ x.ColoSockSecRedirector1Port = C.GoString(xc.colo_sock_sec_redirector1_port)
+ x.ColoFilterSecRedirector0Queue = C.GoString(xc.colo_filter_sec_redirector0_queue)
+ x.ColoFilterSecRedirector0Indev = C.GoString(xc.colo_filter_sec_redirector0_indev)
+ x.ColoFilterSecRedirector0Outdev = C.GoString(xc.colo_filter_sec_redirector0_outdev)
+ x.ColoFilterSecRedirector1Queue = C.GoString(xc.colo_filter_sec_redirector1_queue)
+ x.ColoFilterSecRedirector1Indev = C.GoString(xc.colo_filter_sec_redirector1_indev)
+ x.ColoFilterSecRedirector1Outdev = C.GoString(xc.colo_filter_sec_redirector1_outdev)
+ x.ColoFilterSecRewriter0Queue = C.GoString(xc.colo_filter_sec_rewriter0_queue)
+ x.ColoCheckpointHost = C.GoString(xc.colo_checkpoint_host)
+ x.ColoCheckpointPort = C.GoString(xc.colo_checkpoint_port)
+
+ return nil
+}
+
+func (x *DevicePci) fromC(xc *C.libxl_device_pci) error {
+ x.Func = byte(xc._func)
+ x.Dev = byte(xc.dev)
+ x.Bus = byte(xc.bus)
+ x.Domain = int(xc.domain)
+ x.Vdevfn = uint32(xc.vdevfn)
+ x.VfuncMask = uint32(xc.vfunc_mask)
+ x.Msitranslate = bool(xc.msitranslate)
+ x.PowerMgmt = bool(xc.power_mgmt)
+ x.Permissive = bool(xc.permissive)
+ x.Seize = bool(xc.seize)
+ x.RdmPolicy = RdmReservePolicy(xc.rdm_policy)
+
+ return nil
+}
+
+func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) error {
+ x.Start = uint64(xc.start)
+ x.Size = uint64(xc.size)
+ x.Policy = RdmReservePolicy(xc.policy)
+
+ return nil
+}
+
+func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error {
+ x.Type = UsbctrlType(xc._type)
+ x.Devid = Devid(xc.devid)
+ x.Version = int(xc.version)
+ x.Ports = int(xc.ports)
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+
+ return nil
+}
+
+func (x *DeviceUsbdev) fromC(xc *C.libxl_device_usbdev) error {
+ x.Ctrl = Devid(xc.ctrl)
+ x.Port = int(xc.port)
+
+ return nil
+}
+
+func (x *DeviceDtdev) fromC(xc *C.libxl_device_dtdev) error {
+ x.Path = C.GoString(xc.path)
+
+ return nil
+}
+
+func (x *DeviceVtpm) fromC(xc *C.libxl_device_vtpm) error {
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+ x.Devid = Devid(xc.devid)
+ if err := x.Uuid.fromC(&xc.uuid); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error {
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+ x.Tag = C.GoString(xc.tag)
+ x.Path = C.GoString(xc.path)
+ x.SecurityModel = C.GoString(xc.security_model)
+ x.Devid = Devid(xc.devid)
+
+ return nil
+}
+
+func (x *DevicePvcallsif) fromC(xc *C.libxl_device_pvcallsif) error {
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+ x.Devid = Devid(xc.devid)
+
+ return nil
+}
+
+func (x *DeviceChannel) fromC(xc *C.libxl_device_channel) error {
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+ x.Devid = Devid(xc.devid)
+ x.Name = C.GoString(xc.name)
+
+ return nil
+}
+
+func (x *ConnectorParam) fromC(xc *C.libxl_connector_param) error {
+ x.UniqueId = C.GoString(xc.unique_id)
+ x.Width = uint32(xc.width)
+ x.Height = uint32(xc.height)
+
+ return nil
+}
+
+func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdispl) error {
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+ x.Devid = Devid(xc.devid)
+ x.BeAlloc = bool(xc.be_alloc)
+
+ return nil
+}
+
+func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error {
+ x.ChannelsMin = uint32(xc.channels_min)
+ x.ChannelsMax = uint32(xc.channels_max)
+ x.BufferSize = uint32(xc.buffer_size)
+
+ return nil
+}
+
+func (x *VsndStream) fromC(xc *C.libxl_vsnd_stream) error {
+ x.UniqueId = C.GoString(xc.unique_id)
+ x.Type = VsndStreamType(xc._type)
+ if err := x.Params.fromC(&xc.params); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error {
+ x.Name = C.GoString(xc.name)
+ if err := x.Params.fromC(&xc.params); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error {
+ x.BackendDomid = Domid(xc.backend_domid)
+ x.BackendDomname = C.GoString(xc.backend_domname)
+ x.Devid = Devid(xc.devid)
+ x.ShortName = C.GoString(xc.short_name)
+ x.LongName = C.GoString(xc.long_name)
+ if err := x.Params.fromC(&xc.params); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error {
+ if err := x.CInfo.fromC(&xc.c_info); err != nil {
+ return err
+ }
+ if err := x.BInfo.fromC(&xc.b_info); err != nil {
+ return err
+ }
+ x.OnPoweroff = ActionOnShutdown(xc.on_poweroff)
+ x.OnReboot = ActionOnShutdown(xc.on_reboot)
+ x.OnWatchdog = ActionOnShutdown(xc.on_watchdog)
+ x.OnCrash = ActionOnShutdown(xc.on_crash)
+ x.OnSoftReset = ActionOnShutdown(xc.on_soft_reset)
+
+ return nil
+}
+
+func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error {
+ x.Backend = C.GoString(xc.backend)
+ x.BackendId = uint32(xc.backend_id)
+ x.Frontend = C.GoString(xc.frontend)
+ x.FrontendId = uint32(xc.frontend_id)
+ x.Devid = Devid(xc.devid)
+ x.State = int(xc.state)
+ x.Evtch = int(xc.evtch)
+ x.Rref = int(xc.rref)
+
+ return nil
+}
+
+func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error {
+ x.Backend = C.GoString(xc.backend)
+ x.BackendId = uint32(xc.backend_id)
+ x.Frontend = C.GoString(xc.frontend)
+ x.FrontendId = uint32(xc.frontend_id)
+ x.Devid = Devid(xc.devid)
+ x.State = int(xc.state)
+ x.Evtch = int(xc.evtch)
+ x.RrefTx = int(xc.rref_tx)
+ x.RrefRx = int(xc.rref_rx)
+
+ return nil
+}
+
+func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error {
+ x.Backend = C.GoString(xc.backend)
+ x.BackendId = uint32(xc.backend_id)
+ x.Frontend = C.GoString(xc.frontend)
+ x.FrontendId = uint32(xc.frontend_id)
+ x.Devid = Devid(xc.devid)
+ x.State = int(xc.state)
+ x.Evtch = int(xc.evtch)
+ x.Rref = int(xc.rref)
+ if err := x.Uuid.fromC(&xc.uuid); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo) error {
+ x.Type = UsbctrlType(xc._type)
+ x.Devid = Devid(xc.devid)
+ x.Version = int(xc.version)
+ x.Ports = int(xc.ports)
+ x.Backend = C.GoString(xc.backend)
+ x.BackendId = uint32(xc.backend_id)
+ x.Frontend = C.GoString(xc.frontend)
+ x.FrontendId = uint32(xc.frontend_id)
+ x.State = int(xc.state)
+ x.Evtch = int(xc.evtch)
+ x.RefUrb = int(xc.ref_urb)
+ x.RefConn = int(xc.ref_conn)
+
+ return nil
+}
+
+func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error {
+ x.Vcpuid = uint32(xc.vcpuid)
+ x.Cpu = uint32(xc.cpu)
+ x.Online = bool(xc.online)
+ x.Blocked = bool(xc.blocked)
+ x.Running = bool(xc.running)
+ x.VcpuTime = uint64(xc.vcpu_time)
+ if err := x.Cpumap.fromC(&xc.cpumap); err != nil {
+ return err
+ }
+ if err := x.CpumapSoft.fromC(&xc.cpumap_soft); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *Physinfo) fromC(xc *C.libxl_physinfo) error {
+ x.ThreadsPerCore = uint32(xc.threads_per_core)
+ x.CoresPerSocket = uint32(xc.cores_per_socket)
+ x.MaxCpuId = uint32(xc.max_cpu_id)
+ x.NrCpus = uint32(xc.nr_cpus)
+ x.CpuKhz = uint32(xc.cpu_khz)
+ x.TotalPages = uint64(xc.total_pages)
+ x.FreePages = uint64(xc.free_pages)
+ x.ScrubPages = uint64(xc.scrub_pages)
+ x.OutstandingPages = uint64(xc.outstanding_pages)
+ x.SharingFreedPages = uint64(xc.sharing_freed_pages)
+ x.SharingUsedFrames = uint64(xc.sharing_used_frames)
+ x.MaxPossibleMfn = uint64(xc.max_possible_mfn)
+ x.NrNodes = uint32(xc.nr_nodes)
+ if err := x.HwCap.fromC(&xc.hw_cap); err != nil {
+ return err
+ }
+ x.CapHvm = bool(xc.cap_hvm)
+ x.CapPv = bool(xc.cap_pv)
+ x.CapHvmDirectio = bool(xc.cap_hvm_directio)
+ x.CapHap = bool(xc.cap_hap)
+ x.CapShadow = bool(xc.cap_shadow)
+ x.CapIommuHapPtShare = bool(xc.cap_iommu_hap_pt_share)
+
+ return nil
+}
+
+func (x *Connectorinfo) fromC(xc *C.libxl_connectorinfo) error {
+ x.UniqueId = C.GoString(xc.unique_id)
+ x.Width = uint32(xc.width)
+ x.Height = uint32(xc.height)
+ x.ReqEvtch = int(xc.req_evtch)
+ x.ReqRref = int(xc.req_rref)
+ x.EvtEvtch = int(xc.evt_evtch)
+ x.EvtRref = int(xc.evt_rref)
+
+ return nil
+}
+
+func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error {
+ x.Backend = C.GoString(xc.backend)
+ x.BackendId = uint32(xc.backend_id)
+ x.Frontend = C.GoString(xc.frontend)
+ x.FrontendId = uint32(xc.frontend_id)
+ x.Devid = Devid(xc.devid)
+ x.State = int(xc.state)
+ x.BeAlloc = bool(xc.be_alloc)
+
+ return nil
+}
+
+func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error {
+ x.ReqEvtch = int(xc.req_evtch)
+ x.ReqRref = int(xc.req_rref)
+
+ return nil
+}
+
+func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error {
+
+ return nil
+}
+
+func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error {
+ x.Backend = C.GoString(xc.backend)
+ x.BackendId = uint32(xc.backend_id)
+ x.Frontend = C.GoString(xc.frontend)
+ x.FrontendId = uint32(xc.frontend_id)
+ x.Devid = Devid(xc.devid)
+ x.State = int(xc.state)
+
+ return nil
+}
+
+func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error {
+ x.Backend = C.GoString(xc.backend)
+ x.BackendId = uint32(xc.backend_id)
+ x.Frontend = C.GoString(xc.frontend)
+ x.FrontendId = uint32(xc.frontend_id)
+ x.Devid = Devid(xc.devid)
+ x.State = int(xc.state)
+ x.Evtch = int(xc.evtch)
+ x.Rref = int(xc.rref)
+
+ return nil
+}
+
+func (x *Numainfo) fromC(xc *C.libxl_numainfo) error {
+ x.Size = uint64(xc.size)
+ x.Free = uint64(xc.free)
+
+ return nil
+}
+
+func (x *Cputopology) fromC(xc *C.libxl_cputopology) error {
+ x.Core = uint32(xc.core)
+ x.Socket = uint32(xc.socket)
+ x.Node = uint32(xc.node)
+
+ return nil
+}
+
+func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error {
+ x.Seg = uint16(xc.seg)
+ x.Bus = byte(xc.bus)
+ x.Devfn = byte(xc.devfn)
+ x.Node = uint32(xc.node)
+
+ return nil
+}
+
+func (x *SchedCreditParams) fromC(xc *C.libxl_sched_credit_params) error {
+ x.TsliceMs = int(xc.tslice_ms)
+ x.RatelimitUs = int(xc.ratelimit_us)
+ x.VcpuMigrDelayUs = int(xc.vcpu_migr_delay_us)
+
+ return nil
+}
+
+func (x *SchedCredit2Params) fromC(xc *C.libxl_sched_credit2_params) error {
+ x.RatelimitUs = int(xc.ratelimit_us)
+
+ return nil
+}
+
+func (x *DomainRemusInfo) fromC(xc *C.libxl_domain_remus_info) error {
+ x.Interval = int(xc.interval)
+ if err := x.AllowUnsafe.fromC(&xc.allow_unsafe); err != nil {
+ return err
+ }
+ if err := x.Blackhole.fromC(&xc.blackhole); err != nil {
+ return err
+ }
+ if err := x.Compression.fromC(&xc.compression); err != nil {
+ return err
+ }
+ if err := x.Netbuf.fromC(&xc.netbuf); err != nil {
+ return err
+ }
+ x.Netbufscript = C.GoString(xc.netbufscript)
+ if err := x.Diskbuf.fromC(&xc.diskbuf); err != nil {
+ return err
+ }
+ if err := x.Colo.fromC(&xc.colo); err != nil {
+ return err
+ }
+ if err := x.UserspaceColoProxy.fromC(&xc.userspace_colo_proxy); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (x *Event) fromC(xc *C.libxl_event) error {
+ if err := x.Link.fromC(&xc.link); err != nil {
+ return err
+ }
+ x.Domid = Domid(xc.domid)
+ if err := x.Domuuid.fromC(&xc.domuuid); err != nil {
+ return err
+ }
+ x.ForUser = uint64(xc.for_user)
+
+ return nil
+}
+
+func (x *PsrCatInfo) fromC(xc *C.libxl_psr_cat_info) error {
+ x.Id = uint32(xc.id)
+ x.CosMax = uint32(xc.cos_max)
+ x.CbmLen = uint32(xc.cbm_len)
+ x.CdpEnabled = bool(xc.cdp_enabled)
+
+ return nil
+}
+
+func (x *PsrHwInfo) fromC(xc *C.libxl_psr_hw_info) error {
+ x.Id = uint32(xc.id)
+
+ return nil
+}
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index fb1c6d9e51..f32eb11384 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -405,47 +405,6 @@ func (bm *Bitmap) toC() (C.libxl_bitmap, error) {
return cbm, nil
}
-func (cphys *C.libxl_physinfo) toGo() (physinfo *Physinfo) {
-
- physinfo = &Physinfo{}
- physinfo.ThreadsPerCore = uint32(cphys.threads_per_core)
- physinfo.CoresPerSocket = uint32(cphys.cores_per_socket)
- physinfo.MaxCpuId = uint32(cphys.max_cpu_id)
- physinfo.NrCpus = uint32(cphys.nr_cpus)
- physinfo.CpuKhz = uint32(cphys.cpu_khz)
- physinfo.TotalPages = uint64(cphys.total_pages)
- physinfo.FreePages = uint64(cphys.free_pages)
- physinfo.ScrubPages = uint64(cphys.scrub_pages)
- physinfo.ScrubPages = uint64(cphys.scrub_pages)
- physinfo.SharingFreedPages = uint64(cphys.sharing_freed_pages)
- physinfo.SharingUsedFrames = uint64(cphys.sharing_used_frames)
- physinfo.NrNodes = uint32(cphys.nr_nodes)
- physinfo.HwCap.fromC(&cphys.hw_cap)
- physinfo.CapHvm = bool(cphys.cap_hvm)
- physinfo.CapHvmDirectio = bool(cphys.cap_hvm_directio)
-
- return
-}
-
-func (cinfo *C.libxl_version_info) toGo() (info *VersionInfo) {
- info = &VersionInfo{}
- info.XenVersionMajor = int(cinfo.xen_version_major)
- info.XenVersionMinor = int(cinfo.xen_version_minor)
- info.XenVersionExtra = C.GoString(cinfo.xen_version_extra)
- info.Compiler = C.GoString(cinfo.compiler)
- info.CompileBy = C.GoString(cinfo.compile_by)
- info.CompileDomain = C.GoString(cinfo.compile_domain)
- info.CompileDate = C.GoString(cinfo.compile_date)
- info.Capabilities = C.GoString(cinfo.capabilities)
- info.Changeset = C.GoString(cinfo.changeset)
- info.VirtStart = uint64(cinfo.virt_start)
- info.Pagesize = int(cinfo.pagesize)
- info.Commandline = C.GoString(cinfo.commandline)
- info.BuildId = C.GoString(cinfo.build_id)
-
- return
-}
-
func (sr ShutdownReason) String() (str string) {
cstr := C.libxl_shutdown_reason_to_string(C.libxl_shutdown_reason(sr))
str = C.GoString(cstr)
@@ -460,34 +419,6 @@ func (dt DomainType) String() (str string) {
return
}
-func (cdi *C.libxl_dominfo) toGo() (di *Dominfo) {
-
- di = &Dominfo{}
- di.Uuid.fromC(&cdi.uuid)
- di.Domid = Domid(cdi.domid)
- di.Ssidref = uint32(cdi.ssidref)
- di.SsidLabel = C.GoString(cdi.ssid_label)
- di.Running = bool(cdi.running)
- di.Blocked = bool(cdi.blocked)
- di.Paused = bool(cdi.paused)
- di.Shutdown = bool(cdi.shutdown)
- di.Dying = bool(cdi.dying)
- di.NeverStop = bool(cdi.never_stop)
- di.ShutdownReason = ShutdownReason(cdi.shutdown_reason)
- di.OutstandingMemkb = uint64(cdi.outstanding_memkb)
- di.CurrentMemkb = uint64(cdi.current_memkb)
- di.SharedMemkb = uint64(cdi.shared_memkb)
- di.PagedMemkb = uint64(cdi.paged_memkb)
- di.MaxMemkb = uint64(cdi.max_memkb)
- di.CpuTime = uint64(cdi.cpu_time)
- di.VcpuMaxId = uint32(cdi.vcpu_max_id)
- di.VcpuOnline = uint32(cdi.vcpu_online)
- di.Cpupool = uint32(cdi.cpupool)
- di.DomainType = DomainType(cdi.domain_type)
-
- return
-}
-
// const char *libxl_scheduler_to_string(libxl_scheduler p);
func (s Scheduler) String() string {
cs := C.libxl_scheduler_to_string(C.libxl_scheduler(s))
@@ -519,16 +450,6 @@ func SchedulerFromString(name string) (s Scheduler, err error) {
return
}
-func (cci C.libxl_cpupoolinfo) toGo() (gci Cpupoolinfo) {
- gci.Poolid = uint32(cci.poolid)
- gci.PoolName = C.GoString(cci.pool_name)
- gci.Sched = Scheduler(cci.sched)
- gci.NDom = uint32(cci.n_dom)
- gci.Cpumap.fromC(&cci.cpumap)
-
- return
-}
-
// libxl_cpupoolinfo * libxl_list_cpupool(libxl_ctx*, int *nb_pool_out);
// void libxl_cpupoolinfo_list_free(libxl_cpupoolinfo *list, int nb_pool);
func (Ctx *Context) ListCpupool() (list []Cpupoolinfo) {
@@ -550,7 +471,8 @@ func (Ctx *Context) ListCpupool() (list []Cpupoolinfo) {
// Magic
cpupoolListSlice := (*[1 << 30]C.libxl_cpupoolinfo)(unsafe.Pointer(c_cpupool_list))[:nbPool:nbPool]
for i := range cpupoolListSlice {
- info := cpupoolListSlice[i].toGo()
+ var info Cpupoolinfo
+ _ = info.fromC(&cpupoolListSlice[i])
list = append(list, info)
}
@@ -573,7 +495,7 @@ func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool Cpupoolinfo) {
}
defer C.libxl_cpupoolinfo_dispose(&c_cpupool)
- pool = c_cpupool.toGo()
+ _ = pool.fromC(&c_cpupool)
return
}
@@ -1064,7 +986,7 @@ func (Ctx *Context) GetPhysinfo() (physinfo *Physinfo, err error) {
err = Error(ret)
return
}
- physinfo = cphys.toGo()
+ err = physinfo.fromC(&cphys)
return
}
@@ -1080,7 +1002,7 @@ func (Ctx *Context) GetVersionInfo() (info *VersionInfo, err error) {
cinfo = C.libxl_get_version_info(Ctx.ctx)
- info = cinfo.toGo()
+ err = info.fromC(cinfo)
return
}
@@ -1102,7 +1024,7 @@ func (Ctx *Context) DomainInfo(Id Domid) (di *Dominfo, err error) {
return
}
- di = cdi.toGo()
+ err = di.fromC(&cdi)
return
}
@@ -1184,26 +1106,14 @@ func (Ctx *Context) ListDomain() (glist []Dominfo) {
gslice := (*[1 << 30]C.libxl_dominfo)(unsafe.Pointer(clist))[:nbDomain:nbDomain]
for i := range gslice {
- info := gslice[i].toGo()
- glist = append(glist, *info)
+ var info Dominfo
+ _ = info.fromC(&gslice[i])
+ glist = append(glist, info)
}
return
}
-func (cvci C.libxl_vcpuinfo) toGo() (gvci Vcpuinfo) {
- gvci.Vcpuid = uint32(cvci.vcpuid)
- gvci.Cpu = uint32(cvci.cpu)
- gvci.Online = bool(cvci.online)
- gvci.Blocked = bool(cvci.blocked)
- gvci.Running = bool(cvci.running)
- gvci.VcpuTime = uint64(cvci.vcpu_time)
- gvci.Cpumap.fromC(&cvci.cpumap)
- gvci.CpumapSoft.fromC(&cvci.cpumap_soft)
-
- return
-}
-
//libxl_vcpuinfo *libxl_list_vcpu(libxl_ctx *ctx, uint32_t domid,
// int *nb_vcpu, int *nr_cpus_out);
//void libxl_vcpuinfo_list_free(libxl_vcpuinfo *, int nr_vcpus);
@@ -1225,7 +1135,8 @@ func (Ctx *Context) ListVcpu(id Domid) (glist []Vcpuinfo) {
gslice := (*[1 << 30]C.libxl_vcpuinfo)(unsafe.Pointer(clist))[:nbVcpu:nbVcpu]
for i := range gslice {
- info := gslice[i].toGo()
+ var info Vcpuinfo
+ _ = info.fromC(&gslice[i])
glist = append(glist, info)
}
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* Re: [Xen-devel] [PATCH v3 15/22] golang/xenlight: begin C to Go type marshaling
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 15/22] golang/xenlight: begin C to Go type marshaling Nick Rosbrook
@ 2019-12-16 17:56 ` George Dunlap
0 siblings, 0 replies; 33+ messages in thread
From: George Dunlap @ 2019-12-16 17:56 UTC (permalink / raw)
To: Nick Rosbrook, xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, Wei Liu
On 12/10/19 3:47 PM, Nick Rosbrook wrote:
> From: Nick Rosbrook <rosbrookn@ainfosec.com>
>
> Begin implementation of fromC marshaling functions for generated struct
> types. This includes support for converting fields that are basic
> primitive types such as string and integer types, nested anonymous
> structs, nested libxl structs, and libxl built-in types.
>
> This patch does not implement conversion of arrays or keyed unions.
>
> Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
> ---
> Changes in v2:
> - Add Makefile changes for helpers.gen.go.
> - Re-generate helpers.gen.go to include libxl changes after rebase.
> Changes in v3:
> - Break out field copying/type conversion code into its own function
> called xenlight_golang_convert_from_C to allow that code to be easily
> re-used.
> - Use consistent style for calling fromC on struct fields that require
> it. Namely, do not use a temporary variable - call fromC directly on
> the struct field.
Looks good! One minor comment...
> ---
> tools/golang/xenlight/Makefile | 2 +
> tools/golang/xenlight/gengotypes.py | 118 ++++
> tools/golang/xenlight/helpers.gen.go | 901 +++++++++++++++++++++++++++
> tools/golang/xenlight/xenlight.go | 111 +---
> 4 files changed, 1032 insertions(+), 100 deletions(-)
> create mode 100644 tools/golang/xenlight/helpers.gen.go
>
> diff --git a/tools/golang/xenlight/Makefile b/tools/golang/xenlight/Makefile
> index 681f32c234..07b8896e5b 100644
> --- a/tools/golang/xenlight/Makefile
> +++ b/tools/golang/xenlight/Makefile
> @@ -19,6 +19,7 @@ $(XEN_GOPATH)/src/$(XEN_GOCODE_URL)/xenlight/: %.gen.go
> $(INSTALL_DIR) $(XEN_GOPATH)$(GOXL_PKG_DIR)
> $(INSTALL_DATA) xenlight.go $(XEN_GOPATH)$(GOXL_PKG_DIR)
> $(INSTALL_DATA) types.gen.go $(XEN_GOPATH)$(GOXL_PKG_DIR)
> + $(INSTALL_DATA) helpers.gen.go $(XEN_GOPATH)$(GOXL_PKG_DIR)
I'll have to edit this stanza on check-in to depend on helpers.gen.go
directly; with that:
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 33+ messages in thread
* [Xen-devel] [PATCH v3 16/22] golang/xenlight: implement keyed union C to Go marshaling
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (14 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 15/22] golang/xenlight: begin C to Go type marshaling Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-16 17:57 ` George Dunlap
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 17/22] golang/xenlight: implement array " Nick Rosbrook
` (5 subsequent siblings)
21 siblings, 1 reply; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Switch over union key to determine how to populate 'union' in Go struct.
Since the unions of C types cannot be directly accessed in cgo, use a
typeof trick to typedef a struct in the cgo preamble that is analagous
to each inner struct of a keyed union. For example, to define a struct
for the hvm inner struct of libxl_domain_build_info, do:
typedef typeof(((struct libxl_domain_build_info *)NULL)->u.hvm) libxl_domain_build_info_type_union_hvm;
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
Changes in v2:
- Do not use global variable for extra helper function definitions.
Instead, return a tuple which contains a list of extra helper
functions associated with the original.
Changes in v3:
- Use the new xenlight_golang_convert_from_C function for field copying/
type conversion.
- Use a typeof trick in the cgo preamble to define structs for the inner
struct of keyed unions, instead of explicitly defining the fields.
---
tools/golang/xenlight/gengotypes.py | 129 +++++++++-
tools/golang/xenlight/helpers.gen.go | 346 +++++++++++++++++++++++++++
2 files changed, 464 insertions(+), 11 deletions(-)
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
index 1fe56179e2..b68c1aa66b 100644
--- a/tools/golang/xenlight/gengotypes.py
+++ b/tools/golang/xenlight/gengotypes.py
@@ -24,6 +24,10 @@ go_keywords = ['type', 'func']
go_builtin_types = ['bool', 'string', 'int', 'byte',
'uint16', 'uint32', 'uint64']
+# cgo preamble for xenlight_helpers.go, created during type generation and
+# written later.
+cgo_helpers_preamble = []
+
def xenlight_golang_generate_types(path = None, types = None, comment = None):
"""
Generate a .go file (types.gen.go by default)
@@ -124,7 +128,7 @@ def xenlight_golang_define_struct(ty = None, typename = None, nested = False):
extras.extend(r[1])
elif isinstance(f.type, idl.KeyedUnion):
- r = xenlight_golang_define_union(f.type, ty.typename)
+ r = xenlight_golang_define_union(f.type, ty.typename, f.name)
s += r[0]
extras.extend(r[1])
@@ -137,7 +141,7 @@ def xenlight_golang_define_struct(ty = None, typename = None, nested = False):
return (s,extras)
-def xenlight_golang_define_union(ty = None, structname = ''):
+def xenlight_golang_define_union(ty = None, struct_name = '', union_name = ''):
"""
Generate the Go translation of a KeyedUnion.
@@ -149,7 +153,7 @@ def xenlight_golang_define_union(ty = None, structname = ''):
s = ''
extras = []
- interface_name = '{}_{}_union'.format(structname, ty.keyvar.name)
+ interface_name = '{}_{}_union'.format(struct_name, ty.keyvar.name)
interface_name = xenlight_golang_fmt_name(interface_name, exported=False)
s += 'type {} interface {{\n'.format(interface_name)
@@ -163,11 +167,18 @@ def xenlight_golang_define_union(ty = None, structname = ''):
continue
# Define struct
- name = '{}_{}_union_{}'.format(structname, ty.keyvar.name, f.name)
+ name = '{}_{}_union_{}'.format(struct_name, ty.keyvar.name, f.name)
r = xenlight_golang_define_struct(f.type, typename=name)
extras.append(r[0])
extras.extend(r[1])
+ # This typeof trick ensures that the fields used in the cgo struct
+ # used for marshaling are the same as the fields of the union in the
+ # actual C type, and avoids re-defining all of those fields.
+ s = 'typedef typeof(((struct {} *)NULL)->{}.{}){};'
+ s = s.format(struct_name, union_name, f.name, name)
+ cgo_helpers_preamble.append(s)
+
# Define function to implement 'union' interface
name = xenlight_golang_fmt_name(name)
s = 'func (x {}) is{}(){{}}\n'.format(name, interface_name)
@@ -195,6 +206,7 @@ def xenlight_golang_generate_helpers(path = None, types = None, comment = None):
if comment is not None:
f.write(comment)
f.write('package xenlight\n')
+ f.write('import (\n"unsafe"\n"errors"\n"fmt"\n)\n')
# Cgo preamble
f.write('/*\n')
@@ -203,15 +215,25 @@ def xenlight_golang_generate_helpers(path = None, types = None, comment = None):
f.write('#include <libxl.h>\n')
f.write('\n')
+ for s in cgo_helpers_preamble:
+ f.write(s)
+ f.write('\n')
+
f.write('*/\nimport "C"\n')
for ty in types:
if not isinstance(ty, idl.Struct):
continue
- f.write(xenlight_golang_define_from_C(ty))
+ (fdef, extras) = xenlight_golang_define_from_C(ty)
+
+ f.write(fdef)
f.write('\n')
+ for extra in extras:
+ f.write(extra)
+ f.write('\n')
+
go_fmt(path)
def xenlight_golang_define_from_C(ty = None):
@@ -225,6 +247,7 @@ def xenlight_golang_define_from_C(ty = None):
cname = ty.typename
body = ''
+ extras = []
for f in ty.fields:
if f.type.typename is not None:
@@ -240,14 +263,17 @@ def xenlight_golang_define_from_C(ty = None):
body += xenlight_golang_convert_from_C(nf,outer_name=f.name)
elif isinstance(f.type, idl.KeyedUnion):
- pass
+ r = xenlight_golang_union_from_C(f.type, f.name, ty.typename)
+
+ body += r[0]
+ extras.extend(r[1])
else:
raise Exception('type {} not supported'.format(f.type))
- return func.format(goname, cname, body)
+ return (func.format(goname, cname, body), extras)
-def xenlight_golang_convert_from_C(ty = None, outer_name = None):
+def xenlight_golang_convert_from_C(ty = None, outer_name = None, cvarname = None):
"""
Returns a line of Go code that converts the C type represented
by ty to its corresponding Go type.
@@ -257,6 +283,10 @@ def xenlight_golang_convert_from_C(ty = None, outer_name = None):
"""
s = ''
+ # Use 'xc' as the name for the C variable unless otherwise specified
+ if cvarname is None:
+ cvarname = 'xc'
+
gotypename = xenlight_golang_fmt_name(ty.type.typename)
goname = xenlight_golang_fmt_name(ty.name)
cname = ty.name
@@ -280,18 +310,95 @@ def xenlight_golang_convert_from_C(ty = None, outer_name = None):
if not is_castable:
# If the type is not castable, we need to call its fromC
# function.
- s += 'if err := x.{}.fromC(&xc.{});'.format(goname,cname)
+ s += 'if err := x.{}.fromC(&{}.{});'.format(goname,cvarname,cname)
s += 'err != nil {\n return err \n}\n'
elif gotypename == 'string':
# Use the cgo helper for converting C strings.
- s += 'x.{} = C.GoString(xc.{})\n'.format(goname, cname)
+ s += 'x.{} = C.GoString({}.{})\n'.format(goname,cvarname,cname)
else:
- s += 'x.{} = {}(xc.{})\n'.format(goname, gotypename, cname)
+ s += 'x.{} = {}({}.{})\n'.format(goname,gotypename,cvarname,cname)
return s
+def xenlight_golang_union_from_C(ty = None, union_name = '', struct_name = ''):
+ extras = []
+
+ keyname = ty.keyvar.name
+ gokeyname = xenlight_golang_fmt_name(keyname)
+ keytype = ty.keyvar.type.typename
+ gokeytype = xenlight_golang_fmt_name(keytype)
+
+ interface_name = '{}_{}_union'.format(struct_name, keyname)
+ interface_name = xenlight_golang_fmt_name(interface_name, exported=False)
+
+ cgo_keyname = keyname
+ if cgo_keyname in go_keywords:
+ cgo_keyname = '_' + cgo_keyname
+
+ cases = {}
+
+ for f in ty.fields:
+ val = '{}_{}'.format(keytype, f.name)
+ val = xenlight_golang_fmt_name(val)
+
+ # Add to list of cases to make for the switch
+ # statement below.
+ if f.type is None:
+ continue
+
+ cases[f.name] = val
+
+ # Define fromC func for 'union' struct.
+ typename = '{}_{}_union_{}'.format(struct_name,keyname,f.name)
+ gotypename = xenlight_golang_fmt_name(typename)
+
+ # Define the function here. The cases for keyed unions are a little
+ # different.
+ s = 'func (x *{}) fromC(xc *C.{}) error {{\n'.format(gotypename,struct_name)
+ s += 'if {}(xc.{}) != {} {{\n'.format(gokeytype,cgo_keyname,val)
+ err_string = '"expected union key {}"'.format(val)
+ s += 'return errors.New({})\n'.format(err_string)
+ s += '}\n\n'
+ s += 'tmp := (*C.{})(unsafe.Pointer(&xc.{}[0]))\n'.format(typename,union_name)
+
+ for nf in f.type.fields:
+ s += xenlight_golang_convert_from_C(nf,cvarname='tmp')
+
+ s += 'return nil\n'
+ s += '}\n'
+
+ extras.append(s)
+
+ s = 'x.{} = {}(xc.{})\n'.format(gokeyname,gokeytype,cgo_keyname)
+ s += 'switch x.{}{{\n'.format(gokeyname)
+
+ # Create switch statement to determine which 'union element'
+ # to populate in the Go struct.
+ for case_name, case_val in cases.items():
+ s += 'case {}:\n'.format(case_val)
+
+ gotype = '{}_{}_union_{}'.format(struct_name,keyname,case_name)
+ gotype = xenlight_golang_fmt_name(gotype)
+ goname = '{}_{}'.format(keyname,case_name)
+ goname = xenlight_golang_fmt_name(goname,exported=False)
+
+ s += 'var {} {}\n'.format(goname, gotype)
+ s += 'if err := {}.fromC(xc);'.format(goname)
+ s += 'err != nil {\n return err \n}\n'
+
+ field_name = xenlight_golang_fmt_name('{}_union'.format(keyname))
+ s += 'x.{} = {}\n'.format(field_name, goname)
+
+ # End switch statement
+ s += 'default:\n'
+ err_string = '"invalid union key \'%v\'", x.{}'.format(gokeyname)
+ s += 'return fmt.Errorf({})'.format(err_string)
+ s += '}\n'
+
+ return (s,extras)
+
def xenlight_golang_fmt_name(name, exported = True):
"""
Take a given type name and return an
diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go
index 576aebcf6d..e6eee234c0 100644
--- a/tools/golang/xenlight/helpers.gen.go
+++ b/tools/golang/xenlight/helpers.gen.go
@@ -5,11 +5,28 @@
//
package xenlight
+import (
+ "errors"
+ "fmt"
+ "unsafe"
+)
+
/*
#cgo LDFLAGS: -lxenlight
#include <stdlib.h>
#include <libxl.h>
+typedef typeof(((struct libxl_channelinfo *)NULL)->u.pty)libxl_channelinfo_connection_union_pty;
+typedef typeof(((struct libxl_domain_build_info *)NULL)->u.hvm)libxl_domain_build_info_type_union_hvm;
+typedef typeof(((struct libxl_domain_build_info *)NULL)->u.pv)libxl_domain_build_info_type_union_pv;
+typedef typeof(((struct libxl_domain_build_info *)NULL)->u.pvh)libxl_domain_build_info_type_union_pvh;
+typedef typeof(((struct libxl_device_usbdev *)NULL)->u.hostdev)libxl_device_usbdev_type_union_hostdev;
+typedef typeof(((struct libxl_device_channel *)NULL)->u.socket)libxl_device_channel_connection_union_socket;
+typedef typeof(((struct libxl_event *)NULL)->u.domain_shutdown)libxl_event_type_union_domain_shutdown;
+typedef typeof(((struct libxl_event *)NULL)->u.disk_eject)libxl_event_type_union_disk_eject;
+typedef typeof(((struct libxl_event *)NULL)->u.operation_complete)libxl_event_type_union_operation_complete;
+typedef typeof(((struct libxl_psr_hw_info *)NULL)->u.cat)libxl_psr_hw_info_type_union_cat;
+typedef typeof(((struct libxl_psr_hw_info *)NULL)->u.mba)libxl_psr_hw_info_type_union_mba;
*/
import "C"
@@ -137,7 +154,28 @@ func (x *Channelinfo) fromC(xc *C.libxl_channelinfo) error {
x.State = int(xc.state)
x.Evtch = int(xc.evtch)
x.Rref = int(xc.rref)
+ x.Connection = ChannelConnection(xc.connection)
+ switch x.Connection {
+ case ChannelConnectionPty:
+ var connectionPty ChannelinfoConnectionUnionPty
+ if err := connectionPty.fromC(xc); err != nil {
+ return err
+ }
+ x.ConnectionUnion = connectionPty
+ default:
+ return fmt.Errorf("invalid union key '%v'", x.Connection)
+ }
+
+ return nil
+}
+
+func (x *ChannelinfoConnectionUnionPty) fromC(xc *C.libxl_channelinfo) error {
+ if ChannelConnection(xc.connection) != ChannelConnectionPty {
+ return errors.New("expected union key ChannelConnectionPty")
+ }
+ tmp := (*C.libxl_channelinfo_connection_union_pty)(unsafe.Pointer(&xc.u[0]))
+ x.Path = C.GoString(tmp.path)
return nil
}
@@ -340,6 +378,29 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error {
return err
}
x.Tee = TeeType(xc.tee)
+ x.Type = DomainType(xc._type)
+ switch x.Type {
+ case DomainTypePv:
+ var typePv DomainBuildInfoTypeUnionPv
+ if err := typePv.fromC(xc); err != nil {
+ return err
+ }
+ x.TypeUnion = typePv
+ case DomainTypeHvm:
+ var typeHvm DomainBuildInfoTypeUnionHvm
+ if err := typeHvm.fromC(xc); err != nil {
+ return err
+ }
+ x.TypeUnion = typeHvm
+ case DomainTypePvh:
+ var typePvh DomainBuildInfoTypeUnionPvh
+ if err := typePvh.fromC(xc); err != nil {
+ return err
+ }
+ x.TypeUnion = typePvh
+ default:
+ return fmt.Errorf("invalid union key '%v'", x.Type)
+ }
x.ArchArm.GicVersion = GicVersion(xc.arch_arm.gic_version)
x.ArchArm.Vuart = VuartType(xc.arch_arm.vuart)
x.Altp2M = Altp2MMode(xc.altp2m)
@@ -347,6 +408,151 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error {
return nil
}
+func (x *DomainBuildInfoTypeUnionHvm) fromC(xc *C.libxl_domain_build_info) error {
+ if DomainType(xc._type) != DomainTypeHvm {
+ return errors.New("expected union key DomainTypeHvm")
+ }
+
+ tmp := (*C.libxl_domain_build_info_type_union_hvm)(unsafe.Pointer(&xc.u[0]))
+ x.Firmware = C.GoString(tmp.firmware)
+ x.Bios = BiosType(tmp.bios)
+ if err := x.Pae.fromC(&tmp.pae); err != nil {
+ return err
+ }
+ if err := x.Apic.fromC(&tmp.apic); err != nil {
+ return err
+ }
+ if err := x.Acpi.fromC(&tmp.acpi); err != nil {
+ return err
+ }
+ if err := x.AcpiS3.fromC(&tmp.acpi_s3); err != nil {
+ return err
+ }
+ if err := x.AcpiS4.fromC(&tmp.acpi_s4); err != nil {
+ return err
+ }
+ if err := x.AcpiLaptopSlate.fromC(&tmp.acpi_laptop_slate); err != nil {
+ return err
+ }
+ if err := x.Nx.fromC(&tmp.nx); err != nil {
+ return err
+ }
+ if err := x.Viridian.fromC(&tmp.viridian); err != nil {
+ return err
+ }
+ if err := x.ViridianEnable.fromC(&tmp.viridian_enable); err != nil {
+ return err
+ }
+ if err := x.ViridianDisable.fromC(&tmp.viridian_disable); err != nil {
+ return err
+ }
+ x.Timeoffset = C.GoString(tmp.timeoffset)
+ if err := x.Hpet.fromC(&tmp.hpet); err != nil {
+ return err
+ }
+ if err := x.VptAlign.fromC(&tmp.vpt_align); err != nil {
+ return err
+ }
+ x.MmioHoleMemkb = uint64(tmp.mmio_hole_memkb)
+ x.TimerMode = TimerMode(tmp.timer_mode)
+ if err := x.NestedHvm.fromC(&tmp.nested_hvm); err != nil {
+ return err
+ }
+ if err := x.Altp2M.fromC(&tmp.altp2m); err != nil {
+ return err
+ }
+ x.SystemFirmware = C.GoString(tmp.system_firmware)
+ x.SmbiosFirmware = C.GoString(tmp.smbios_firmware)
+ x.AcpiFirmware = C.GoString(tmp.acpi_firmware)
+ x.Hdtype = Hdtype(tmp.hdtype)
+ if err := x.Nographic.fromC(&tmp.nographic); err != nil {
+ return err
+ }
+ if err := x.Vga.fromC(&tmp.vga); err != nil {
+ return err
+ }
+ if err := x.Vnc.fromC(&tmp.vnc); err != nil {
+ return err
+ }
+ x.Keymap = C.GoString(tmp.keymap)
+ if err := x.Sdl.fromC(&tmp.sdl); err != nil {
+ return err
+ }
+ if err := x.Spice.fromC(&tmp.spice); err != nil {
+ return err
+ }
+ if err := x.GfxPassthru.fromC(&tmp.gfx_passthru); err != nil {
+ return err
+ }
+ x.GfxPassthruKind = GfxPassthruKind(tmp.gfx_passthru_kind)
+ x.Serial = C.GoString(tmp.serial)
+ x.Boot = C.GoString(tmp.boot)
+ if err := x.Usb.fromC(&tmp.usb); err != nil {
+ return err
+ }
+ x.Usbversion = int(tmp.usbversion)
+ x.Usbdevice = C.GoString(tmp.usbdevice)
+ if err := x.VkbDevice.fromC(&tmp.vkb_device); err != nil {
+ return err
+ }
+ x.Soundhw = C.GoString(tmp.soundhw)
+ if err := x.XenPlatformPci.fromC(&tmp.xen_platform_pci); err != nil {
+ return err
+ }
+ if err := x.UsbdeviceList.fromC(&tmp.usbdevice_list); err != nil {
+ return err
+ }
+ x.VendorDevice = VendorDevice(tmp.vendor_device)
+ if err := x.MsVmGenid.fromC(&tmp.ms_vm_genid); err != nil {
+ return err
+ }
+ if err := x.SerialList.fromC(&tmp.serial_list); err != nil {
+ return err
+ }
+ if err := x.Rdm.fromC(&tmp.rdm); err != nil {
+ return err
+ }
+ x.RdmMemBoundaryMemkb = uint64(tmp.rdm_mem_boundary_memkb)
+ x.McaCaps = uint64(tmp.mca_caps)
+ return nil
+}
+
+func (x *DomainBuildInfoTypeUnionPv) fromC(xc *C.libxl_domain_build_info) error {
+ if DomainType(xc._type) != DomainTypePv {
+ return errors.New("expected union key DomainTypePv")
+ }
+
+ tmp := (*C.libxl_domain_build_info_type_union_pv)(unsafe.Pointer(&xc.u[0]))
+ x.Kernel = C.GoString(tmp.kernel)
+ x.SlackMemkb = uint64(tmp.slack_memkb)
+ x.Bootloader = C.GoString(tmp.bootloader)
+ if err := x.BootloaderArgs.fromC(&tmp.bootloader_args); err != nil {
+ return err
+ }
+ x.Cmdline = C.GoString(tmp.cmdline)
+ x.Ramdisk = C.GoString(tmp.ramdisk)
+ x.Features = C.GoString(tmp.features)
+ if err := x.E820Host.fromC(&tmp.e820_host); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (x *DomainBuildInfoTypeUnionPvh) fromC(xc *C.libxl_domain_build_info) error {
+ if DomainType(xc._type) != DomainTypePvh {
+ return errors.New("expected union key DomainTypePvh")
+ }
+
+ tmp := (*C.libxl_domain_build_info_type_union_pvh)(unsafe.Pointer(&xc.u[0]))
+ if err := x.Pvshim.fromC(&tmp.pvshim); err != nil {
+ return err
+ }
+ x.PvshimPath = C.GoString(tmp.pvshim_path)
+ x.PvshimCmdline = C.GoString(tmp.pvshim_cmdline)
+ x.PvshimExtra = C.GoString(tmp.pvshim_extra)
+ return nil
+}
+
func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -520,10 +726,32 @@ func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error {
func (x *DeviceUsbdev) fromC(xc *C.libxl_device_usbdev) error {
x.Ctrl = Devid(xc.ctrl)
x.Port = int(xc.port)
+ x.Type = UsbdevType(xc._type)
+ switch x.Type {
+ case UsbdevTypeHostdev:
+ var typeHostdev DeviceUsbdevTypeUnionHostdev
+ if err := typeHostdev.fromC(xc); err != nil {
+ return err
+ }
+ x.TypeUnion = typeHostdev
+ default:
+ return fmt.Errorf("invalid union key '%v'", x.Type)
+ }
return nil
}
+func (x *DeviceUsbdevTypeUnionHostdev) fromC(xc *C.libxl_device_usbdev) error {
+ if UsbdevType(xc._type) != UsbdevTypeHostdev {
+ return errors.New("expected union key UsbdevTypeHostdev")
+ }
+
+ tmp := (*C.libxl_device_usbdev_type_union_hostdev)(unsafe.Pointer(&xc.u[0]))
+ x.Hostbus = byte(tmp.hostbus)
+ x.Hostaddr = byte(tmp.hostaddr)
+ return nil
+}
+
func (x *DeviceDtdev) fromC(xc *C.libxl_device_dtdev) error {
x.Path = C.GoString(xc.path)
@@ -565,7 +793,28 @@ func (x *DeviceChannel) fromC(xc *C.libxl_device_channel) error {
x.BackendDomname = C.GoString(xc.backend_domname)
x.Devid = Devid(xc.devid)
x.Name = C.GoString(xc.name)
+ x.Connection = ChannelConnection(xc.connection)
+ switch x.Connection {
+ case ChannelConnectionSocket:
+ var connectionSocket DeviceChannelConnectionUnionSocket
+ if err := connectionSocket.fromC(xc); err != nil {
+ return err
+ }
+ x.ConnectionUnion = connectionSocket
+ default:
+ return fmt.Errorf("invalid union key '%v'", x.Connection)
+ }
+
+ return nil
+}
+func (x *DeviceChannelConnectionUnionSocket) fromC(xc *C.libxl_device_channel) error {
+ if ChannelConnection(xc.connection) != ChannelConnectionSocket {
+ return errors.New("expected union key ChannelConnectionSocket")
+ }
+
+ tmp := (*C.libxl_device_channel_connection_union_socket)(unsafe.Pointer(&xc.u[0]))
+ x.Path = C.GoString(tmp.path)
return nil
}
@@ -881,7 +1130,63 @@ func (x *Event) fromC(xc *C.libxl_event) error {
return err
}
x.ForUser = uint64(xc.for_user)
+ x.Type = EventType(xc._type)
+ switch x.Type {
+ case EventTypeOperationComplete:
+ var typeOperationComplete EventTypeUnionOperationComplete
+ if err := typeOperationComplete.fromC(xc); err != nil {
+ return err
+ }
+ x.TypeUnion = typeOperationComplete
+ case EventTypeDomainShutdown:
+ var typeDomainShutdown EventTypeUnionDomainShutdown
+ if err := typeDomainShutdown.fromC(xc); err != nil {
+ return err
+ }
+ x.TypeUnion = typeDomainShutdown
+ case EventTypeDiskEject:
+ var typeDiskEject EventTypeUnionDiskEject
+ if err := typeDiskEject.fromC(xc); err != nil {
+ return err
+ }
+ x.TypeUnion = typeDiskEject
+ default:
+ return fmt.Errorf("invalid union key '%v'", x.Type)
+ }
+
+ return nil
+}
+
+func (x *EventTypeUnionDomainShutdown) fromC(xc *C.libxl_event) error {
+ if EventType(xc._type) != EventTypeDomainShutdown {
+ return errors.New("expected union key EventTypeDomainShutdown")
+ }
+ tmp := (*C.libxl_event_type_union_domain_shutdown)(unsafe.Pointer(&xc.u[0]))
+ x.ShutdownReason = byte(tmp.shutdown_reason)
+ return nil
+}
+
+func (x *EventTypeUnionDiskEject) fromC(xc *C.libxl_event) error {
+ if EventType(xc._type) != EventTypeDiskEject {
+ return errors.New("expected union key EventTypeDiskEject")
+ }
+
+ tmp := (*C.libxl_event_type_union_disk_eject)(unsafe.Pointer(&xc.u[0]))
+ x.Vdev = C.GoString(tmp.vdev)
+ if err := x.Disk.fromC(&tmp.disk); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (x *EventTypeUnionOperationComplete) fromC(xc *C.libxl_event) error {
+ if EventType(xc._type) != EventTypeOperationComplete {
+ return errors.New("expected union key EventTypeOperationComplete")
+ }
+
+ tmp := (*C.libxl_event_type_union_operation_complete)(unsafe.Pointer(&xc.u[0]))
+ x.Rc = int(tmp.rc)
return nil
}
@@ -896,6 +1201,47 @@ func (x *PsrCatInfo) fromC(xc *C.libxl_psr_cat_info) error {
func (x *PsrHwInfo) fromC(xc *C.libxl_psr_hw_info) error {
x.Id = uint32(xc.id)
+ x.Type = PsrFeatType(xc._type)
+ switch x.Type {
+ case PsrFeatTypeMba:
+ var typeMba PsrHwInfoTypeUnionMba
+ if err := typeMba.fromC(xc); err != nil {
+ return err
+ }
+ x.TypeUnion = typeMba
+ case PsrFeatTypeCat:
+ var typeCat PsrHwInfoTypeUnionCat
+ if err := typeCat.fromC(xc); err != nil {
+ return err
+ }
+ x.TypeUnion = typeCat
+ default:
+ return fmt.Errorf("invalid union key '%v'", x.Type)
+ }
+
+ return nil
+}
+
+func (x *PsrHwInfoTypeUnionCat) fromC(xc *C.libxl_psr_hw_info) error {
+ if PsrFeatType(xc._type) != PsrFeatTypeCat {
+ return errors.New("expected union key PsrFeatTypeCat")
+ }
+
+ tmp := (*C.libxl_psr_hw_info_type_union_cat)(unsafe.Pointer(&xc.u[0]))
+ x.CosMax = uint32(tmp.cos_max)
+ x.CbmLen = uint32(tmp.cbm_len)
+ x.CdpEnabled = bool(tmp.cdp_enabled)
+ return nil
+}
+
+func (x *PsrHwInfoTypeUnionMba) fromC(xc *C.libxl_psr_hw_info) error {
+ if PsrFeatType(xc._type) != PsrFeatTypeMba {
+ return errors.New("expected union key PsrFeatTypeMba")
+ }
+ tmp := (*C.libxl_psr_hw_info_type_union_mba)(unsafe.Pointer(&xc.u[0]))
+ x.CosMax = uint32(tmp.cos_max)
+ x.ThrtlMax = uint32(tmp.thrtl_max)
+ x.Linear = bool(tmp.linear)
return nil
}
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* Re: [Xen-devel] [PATCH v3 16/22] golang/xenlight: implement keyed union C to Go marshaling
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 16/22] golang/xenlight: implement keyed union C to Go marshaling Nick Rosbrook
@ 2019-12-16 17:57 ` George Dunlap
0 siblings, 0 replies; 33+ messages in thread
From: George Dunlap @ 2019-12-16 17:57 UTC (permalink / raw)
To: Nick Rosbrook, xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, Wei Liu
On 12/10/19 3:47 PM, Nick Rosbrook wrote:
> From: Nick Rosbrook <rosbrookn@ainfosec.com>
>
> Switch over union key to determine how to populate 'union' in Go struct.
>
> Since the unions of C types cannot be directly accessed in cgo, use a
> typeof trick to typedef a struct in the cgo preamble that is analagous
> to each inner struct of a keyed union. For example, to define a struct
> for the hvm inner struct of libxl_domain_build_info, do:
>
> typedef typeof(((struct libxl_domain_build_info *)NULL)->u.hvm) libxl_domain_build_info_type_union_hvm;
>
> Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Looks great, thanks:
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 33+ messages in thread
* [Xen-devel] [PATCH v3 17/22] golang/xenlight: implement array C to Go marshaling
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (15 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 16/22] golang/xenlight: implement keyed union C to Go marshaling Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-17 11:16 ` George Dunlap
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 18/22] golang/xenlight: begin Go to C type marshaling Nick Rosbrook
` (4 subsequent siblings)
21 siblings, 1 reply; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
tools/golang/xenlight/gengotypes.py | 39 +++-
tools/golang/xenlight/helpers.gen.go | 300 +++++++++++++++++++++++++++
2 files changed, 338 insertions(+), 1 deletion(-)
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
index b68c1aa66b..ee9aaf9eff 100644
--- a/tools/golang/xenlight/gengotypes.py
+++ b/tools/golang/xenlight/gengotypes.py
@@ -252,7 +252,7 @@ def xenlight_golang_define_from_C(ty = None):
for f in ty.fields:
if f.type.typename is not None:
if isinstance(f.type, idl.Array):
- # TODO
+ body += xenlight_golang_array_from_C(f)
continue
body += xenlight_golang_convert_from_C(f)
@@ -399,6 +399,43 @@ def xenlight_golang_union_from_C(ty = None, union_name = '', struct_name = ''):
return (s,extras)
+def xenlight_golang_array_from_C(ty = None):
+ """
+ Convert C array to Go slice using the method
+ described here:
+
+ https://github.com/golang/go/wiki/cgo#turning-c-arrays-into-go-slices
+ """
+ s = ''
+
+ gotypename = xenlight_golang_fmt_name(ty.type.elem_type.typename)
+ goname = xenlight_golang_fmt_name(ty.name)
+ ctypename = ty.type.elem_type.typename
+ cname = ty.name
+ cslice = 'c{}'.format(goname)
+ clenvar = ty.type.lenvar.name
+ golenvar = xenlight_golang_fmt_name(clenvar,exported=False)
+
+ s += '{} := int(xc.{})\n'.format(golenvar, clenvar)
+ s += '{} := '.format(cslice)
+ s +='(*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.format(ctypename, cname,
+ golenvar, golenvar)
+ s += 'x.{} = make([]{}, {})\n'.format(goname, gotypename, golenvar)
+ s += 'for i, v := range {} {{\n'.format(cslice)
+
+ is_enum = isinstance(ty.type.elem_type,idl.Enumeration)
+ if gotypename in go_builtin_types or is_enum:
+ s += 'x.{}[i] = {}(v)\n'.format(goname, gotypename)
+ else:
+ s += 'var e {}\n'.format(gotypename)
+ s += 'if err := e.fromC(&v); err != nil {\n'
+ s += 'return err }\n'
+ s += 'x.{}[i] = e\n'.format(goname)
+
+ s += '}\n'
+
+ return s
+
def xenlight_golang_fmt_name(name, exported = True):
"""
Take a given type name and return an
diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go
index e6eee234c0..2f917cac58 100644
--- a/tools/golang/xenlight/helpers.gen.go
+++ b/tools/golang/xenlight/helpers.gen.go
@@ -263,6 +263,16 @@ func (x *SchedParams) fromC(xc *C.libxl_sched_params) error {
func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
x.Sched = Scheduler(xc.sched)
+ numVcpus := int(xc.num_vcpus)
+ cVcpus := (*[1 << 28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:numVcpus:numVcpus]
+ x.Vcpus = make([]SchedParams, numVcpus)
+ for i, v := range cVcpus {
+ var e SchedParams
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Vcpus[i] = e
+ }
return nil
}
@@ -282,6 +292,12 @@ func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error {
func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error {
x.Memkb = uint64(xc.memkb)
+ numDistances := int(xc.num_distances)
+ cDistances := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.distances))[:numDistances:numDistances]
+ x.Distances = make([]uint32, numDistances)
+ for i, v := range cDistances {
+ x.Distances[i] = uint32(v)
+ }
x.Pnode = uint32(xc.pnode)
if err := x.Vcpus.fromC(&xc.vcpus); err != nil {
return err
@@ -308,6 +324,26 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error {
if err := x.Nodemap.fromC(&xc.nodemap); err != nil {
return err
}
+ numVcpuHardAffinity := int(xc.num_vcpu_hard_affinity)
+ cVcpuHardAffinity := (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_hard_affinity))[:numVcpuHardAffinity:numVcpuHardAffinity]
+ x.VcpuHardAffinity = make([]Bitmap, numVcpuHardAffinity)
+ for i, v := range cVcpuHardAffinity {
+ var e Bitmap
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.VcpuHardAffinity[i] = e
+ }
+ numVcpuSoftAffinity := int(xc.num_vcpu_soft_affinity)
+ cVcpuSoftAffinity := (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_soft_affinity))[:numVcpuSoftAffinity:numVcpuSoftAffinity]
+ x.VcpuSoftAffinity = make([]Bitmap, numVcpuSoftAffinity)
+ for i, v := range cVcpuSoftAffinity {
+ var e Bitmap
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.VcpuSoftAffinity[i] = e
+ }
if err := x.NumaPlacement.fromC(&xc.numa_placement); err != nil {
return err
}
@@ -330,6 +366,16 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error {
return err
}
x.BlkdevStart = C.GoString(xc.blkdev_start)
+ numVnumaNodes := int(xc.num_vnuma_nodes)
+ cVnumaNodes := (*[1 << 28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_nodes))[:numVnumaNodes:numVnumaNodes]
+ x.VnumaNodes = make([]VnodeInfo, numVnumaNodes)
+ for i, v := range cVnumaNodes {
+ var e VnodeInfo
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.VnumaNodes[i] = e
+ }
x.MaxGrantFrames = uint32(xc.max_grant_frames)
x.MaxMaptrackFrames = uint32(xc.max_maptrack_frames)
x.DeviceModelVersion = DeviceModelVersion(xc.device_model_version)
@@ -352,6 +398,32 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error {
if err := x.SchedParams.fromC(&xc.sched_params); err != nil {
return err
}
+ numIoports := int(xc.num_ioports)
+ cIoports := (*[1 << 28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports))[:numIoports:numIoports]
+ x.Ioports = make([]IoportRange, numIoports)
+ for i, v := range cIoports {
+ var e IoportRange
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Ioports[i] = e
+ }
+ numIrqs := int(xc.num_irqs)
+ cIrqs := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:numIrqs:numIrqs]
+ x.Irqs = make([]uint32, numIrqs)
+ for i, v := range cIrqs {
+ x.Irqs[i] = uint32(v)
+ }
+ numIomem := int(xc.num_iomem)
+ cIomem := (*[1 << 28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:numIomem:numIomem]
+ x.Iomem = make([]IomemRange, numIomem)
+ for i, v := range cIomem {
+ var e IomemRange
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Iomem[i] = e
+ }
if err := x.ClaimMode.fromC(&xc.claim_mode); err != nil {
return err
}
@@ -831,11 +903,33 @@ func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdispl) error {
x.BackendDomname = C.GoString(xc.backend_domname)
x.Devid = Devid(xc.devid)
x.BeAlloc = bool(xc.be_alloc)
+ numConnectors := int(xc.num_connectors)
+ cConnectors := (*[1 << 28]C.libxl_connector_param)(unsafe.Pointer(xc.connectors))[:numConnectors:numConnectors]
+ x.Connectors = make([]ConnectorParam, numConnectors)
+ for i, v := range cConnectors {
+ var e ConnectorParam
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Connectors[i] = e
+ }
return nil
}
func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error {
+ numSampleRates := int(xc.num_sample_rates)
+ cSampleRates := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.sample_rates))[:numSampleRates:numSampleRates]
+ x.SampleRates = make([]uint32, numSampleRates)
+ for i, v := range cSampleRates {
+ x.SampleRates[i] = uint32(v)
+ }
+ numSampleFormats := int(xc.num_sample_formats)
+ cSampleFormats := (*[1 << 28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc.sample_formats))[:numSampleFormats:numSampleFormats]
+ x.SampleFormats = make([]VsndPcmFormat, numSampleFormats)
+ for i, v := range cSampleFormats {
+ x.SampleFormats[i] = VsndPcmFormat(v)
+ }
x.ChannelsMin = uint32(xc.channels_min)
x.ChannelsMax = uint32(xc.channels_max)
x.BufferSize = uint32(xc.buffer_size)
@@ -858,6 +952,16 @@ func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error {
if err := x.Params.fromC(&xc.params); err != nil {
return err
}
+ numVsndStreams := int(xc.num_vsnd_streams)
+ cStreams := (*[1 << 28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams]
+ x.Streams = make([]VsndStream, numVsndStreams)
+ for i, v := range cStreams {
+ var e VsndStream
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Streams[i] = e
+ }
return nil
}
@@ -871,6 +975,16 @@ func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error {
if err := x.Params.fromC(&xc.params); err != nil {
return err
}
+ numVsndPcms := int(xc.num_vsnd_pcms)
+ cPcms := (*[1 << 28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms]
+ x.Pcms = make([]VsndPcm, numVsndPcms)
+ for i, v := range cPcms {
+ var e VsndPcm
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Pcms[i] = e
+ }
return nil
}
@@ -882,6 +996,156 @@ func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error {
if err := x.BInfo.fromC(&xc.b_info); err != nil {
return err
}
+ numDisks := int(xc.num_disks)
+ cDisks := (*[1 << 28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:numDisks:numDisks]
+ x.Disks = make([]DeviceDisk, numDisks)
+ for i, v := range cDisks {
+ var e DeviceDisk
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Disks[i] = e
+ }
+ numNics := int(xc.num_nics)
+ cNics := (*[1 << 28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:numNics:numNics]
+ x.Nics = make([]DeviceNic, numNics)
+ for i, v := range cNics {
+ var e DeviceNic
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Nics[i] = e
+ }
+ numPcidevs := int(xc.num_pcidevs)
+ cPcidevs := (*[1 << 28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))[:numPcidevs:numPcidevs]
+ x.Pcidevs = make([]DevicePci, numPcidevs)
+ for i, v := range cPcidevs {
+ var e DevicePci
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Pcidevs[i] = e
+ }
+ numRdms := int(xc.num_rdms)
+ cRdms := (*[1 << 28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:numRdms:numRdms]
+ x.Rdms = make([]DeviceRdm, numRdms)
+ for i, v := range cRdms {
+ var e DeviceRdm
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Rdms[i] = e
+ }
+ numDtdevs := int(xc.num_dtdevs)
+ cDtdevs := (*[1 << 28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))[:numDtdevs:numDtdevs]
+ x.Dtdevs = make([]DeviceDtdev, numDtdevs)
+ for i, v := range cDtdevs {
+ var e DeviceDtdev
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Dtdevs[i] = e
+ }
+ numVfbs := int(xc.num_vfbs)
+ cVfbs := (*[1 << 28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:numVfbs:numVfbs]
+ x.Vfbs = make([]DeviceVfb, numVfbs)
+ for i, v := range cVfbs {
+ var e DeviceVfb
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Vfbs[i] = e
+ }
+ numVkbs := int(xc.num_vkbs)
+ cVkbs := (*[1 << 28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:numVkbs:numVkbs]
+ x.Vkbs = make([]DeviceVkb, numVkbs)
+ for i, v := range cVkbs {
+ var e DeviceVkb
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Vkbs[i] = e
+ }
+ numVtpms := int(xc.num_vtpms)
+ cVtpms := (*[1 << 28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:numVtpms:numVtpms]
+ x.Vtpms = make([]DeviceVtpm, numVtpms)
+ for i, v := range cVtpms {
+ var e DeviceVtpm
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Vtpms[i] = e
+ }
+ numP9S := int(xc.num_p9s)
+ cP9S := (*[1 << 28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:numP9S:numP9S]
+ x.P9S = make([]DeviceP9, numP9S)
+ for i, v := range cP9S {
+ var e DeviceP9
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.P9S[i] = e
+ }
+ numPvcallsifs := int(xc.num_pvcallsifs)
+ cPvcallsifs := (*[1 << 28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.pvcallsifs))[:numPvcallsifs:numPvcallsifs]
+ x.Pvcallsifs = make([]DevicePvcallsif, numPvcallsifs)
+ for i, v := range cPvcallsifs {
+ var e DevicePvcallsif
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Pvcallsifs[i] = e
+ }
+ numVdispls := int(xc.num_vdispls)
+ cVdispls := (*[1 << 28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispls))[:numVdispls:numVdispls]
+ x.Vdispls = make([]DeviceVdispl, numVdispls)
+ for i, v := range cVdispls {
+ var e DeviceVdispl
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Vdispls[i] = e
+ }
+ numVsnds := int(xc.num_vsnds)
+ cVsnds := (*[1 << 28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:numVsnds:numVsnds]
+ x.Vsnds = make([]DeviceVsnd, numVsnds)
+ for i, v := range cVsnds {
+ var e DeviceVsnd
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Vsnds[i] = e
+ }
+ numChannels := int(xc.num_channels)
+ cChannels := (*[1 << 28]C.libxl_device_channel)(unsafe.Pointer(xc.channels))[:numChannels:numChannels]
+ x.Channels = make([]DeviceChannel, numChannels)
+ for i, v := range cChannels {
+ var e DeviceChannel
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Channels[i] = e
+ }
+ numUsbctrls := int(xc.num_usbctrls)
+ cUsbctrls := (*[1 << 28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbctrls))[:numUsbctrls:numUsbctrls]
+ x.Usbctrls = make([]DeviceUsbctrl, numUsbctrls)
+ for i, v := range cUsbctrls {
+ var e DeviceUsbctrl
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Usbctrls[i] = e
+ }
+ numUsbdevs := int(xc.num_usbdevs)
+ cUsbdevs := (*[1 << 28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdevs))[:numUsbdevs:numUsbdevs]
+ x.Usbdevs = make([]DeviceUsbdev, numUsbdevs)
+ for i, v := range cUsbdevs {
+ var e DeviceUsbdev
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Usbdevs[i] = e
+ }
x.OnPoweroff = ActionOnShutdown(xc.on_poweroff)
x.OnReboot = ActionOnShutdown(xc.on_reboot)
x.OnWatchdog = ActionOnShutdown(xc.on_watchdog)
@@ -1015,6 +1279,16 @@ func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error {
x.Devid = Devid(xc.devid)
x.State = int(xc.state)
x.BeAlloc = bool(xc.be_alloc)
+ numConnectors := int(xc.num_connectors)
+ cConnectors := (*[1 << 28]C.libxl_connectorinfo)(unsafe.Pointer(xc.connectors))[:numConnectors:numConnectors]
+ x.Connectors = make([]Connectorinfo, numConnectors)
+ for i, v := range cConnectors {
+ var e Connectorinfo
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Connectors[i] = e
+ }
return nil
}
@@ -1027,6 +1301,16 @@ func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error {
}
func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error {
+ numVsndStreams := int(xc.num_vsnd_streams)
+ cStreams := (*[1 << 28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams]
+ x.Streams = make([]Streaminfo, numVsndStreams)
+ for i, v := range cStreams {
+ var e Streaminfo
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Streams[i] = e
+ }
return nil
}
@@ -1038,6 +1322,16 @@ func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error {
x.FrontendId = uint32(xc.frontend_id)
x.Devid = Devid(xc.devid)
x.State = int(xc.state)
+ numVsndPcms := int(xc.num_vsnd_pcms)
+ cPcms := (*[1 << 28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms]
+ x.Pcms = make([]Pcminfo, numVsndPcms)
+ for i, v := range cPcms {
+ var e Pcminfo
+ if err := e.fromC(&v); err != nil {
+ return err
+ }
+ x.Pcms[i] = e
+ }
return nil
}
@@ -1058,6 +1352,12 @@ func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error {
func (x *Numainfo) fromC(xc *C.libxl_numainfo) error {
x.Size = uint64(xc.size)
x.Free = uint64(xc.free)
+ numDists := int(xc.num_dists)
+ cDists := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.dists))[:numDists:numDists]
+ x.Dists = make([]uint32, numDists)
+ for i, v := range cDists {
+ x.Dists[i] = uint32(v)
+ }
return nil
}
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* Re: [Xen-devel] [PATCH v3 17/22] golang/xenlight: implement array C to Go marshaling
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 17/22] golang/xenlight: implement array " Nick Rosbrook
@ 2019-12-17 11:16 ` George Dunlap
2019-12-17 14:51 ` Nick Rosbrook
0 siblings, 1 reply; 33+ messages in thread
From: George Dunlap @ 2019-12-17 11:16 UTC (permalink / raw)
To: Nick Rosbrook, xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, Wei Liu
On 12/10/19 3:47 PM, Nick Rosbrook wrote:
> From: Nick Rosbrook <rosbrookn@ainfosec.com>
>
> Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
> ---
> tools/golang/xenlight/gengotypes.py | 39 +++-
> tools/golang/xenlight/helpers.gen.go | 300 +++++++++++++++++++++++++++
> 2 files changed, 338 insertions(+), 1 deletion(-)
>
> diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
> index b68c1aa66b..ee9aaf9eff 100644
> --- a/tools/golang/xenlight/gengotypes.py
> +++ b/tools/golang/xenlight/gengotypes.py
> @@ -252,7 +252,7 @@ def xenlight_golang_define_from_C(ty = None):
> for f in ty.fields:
> if f.type.typename is not None:
> if isinstance(f.type, idl.Array):
> - # TODO
> + body += xenlight_golang_array_from_C(f)
> continue
>
> body += xenlight_golang_convert_from_C(f)
> @@ -399,6 +399,43 @@ def xenlight_golang_union_from_C(ty = None, union_name = '', struct_name = ''):
>
> return (s,extras)
>
> +def xenlight_golang_array_from_C(ty = None):
> + """
> + Convert C array to Go slice using the method
> + described here:
> +
> + https://github.com/golang/go/wiki/cgo#turning-c-arrays-into-go-slices
> + """
> + s = ''
> +
> + gotypename = xenlight_golang_fmt_name(ty.type.elem_type.typename)
> + goname = xenlight_golang_fmt_name(ty.name)
> + ctypename = ty.type.elem_type.typename
> + cname = ty.name
> + cslice = 'c{}'.format(goname)
> + clenvar = ty.type.lenvar.name
> + golenvar = xenlight_golang_fmt_name(clenvar,exported=False)
> +
> + s += '{} := int(xc.{})\n'.format(golenvar, clenvar)
> + s += '{} := '.format(cslice)
> + s +='(*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.format(ctypename, cname,
> + golenvar, golenvar)
> + s += 'x.{} = make([]{}, {})\n'.format(goname, gotypename, golenvar)
> + s += 'for i, v := range {} {{\n'.format(cslice)
> +
> + is_enum = isinstance(ty.type.elem_type,idl.Enumeration)
> + if gotypename in go_builtin_types or is_enum:
> + s += 'x.{}[i] = {}(v)\n'.format(goname, gotypename)
> + else:
> + s += 'var e {}\n'.format(gotypename)
> + s += 'if err := e.fromC(&v); err != nil {\n'
> + s += 'return err }\n'
> + s += 'x.{}[i] = e\n'.format(goname)
> +
> + s += '}\n'
> +
> + return s
> +
> def xenlight_golang_fmt_name(name, exported = True):
> """
> Take a given type name and return an
> diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go
> index e6eee234c0..2f917cac58 100644
> --- a/tools/golang/xenlight/helpers.gen.go
> +++ b/tools/golang/xenlight/helpers.gen.go
> @@ -263,6 +263,16 @@ func (x *SchedParams) fromC(xc *C.libxl_sched_params) error {
>
> func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
> x.Sched = Scheduler(xc.sched)
> + numVcpus := int(xc.num_vcpus)
> + cVcpus := (*[1 << 28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:numVcpus:numVcpus]
> + x.Vcpus = make([]SchedParams, numVcpus)
> + for i, v := range cVcpus {
> + var e SchedParams
> + if err := e.fromC(&v); err != nil {
> + return err
> + }
> + x.Vcpus[i] = e
Along the same lines, any reason not to do the following?
if err := x.Vcpus[i].fromC(&v); err != nil {
return err
}
Everything else looks good.
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 33+ messages in thread* Re: [Xen-devel] [PATCH v3 17/22] golang/xenlight: implement array C to Go marshaling
2019-12-17 11:16 ` George Dunlap
@ 2019-12-17 14:51 ` Nick Rosbrook
0 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-17 14:51 UTC (permalink / raw)
To: George Dunlap; +Cc: Nick Rosbrook, Xen-devel, kerriganb, Ian Jackson, Wei Liu
On Tue, Dec 17, 2019 at 6:16 AM George Dunlap <george.dunlap@citrix.com> wrote:
>
> On 12/10/19 3:47 PM, Nick Rosbrook wrote:
> > From: Nick Rosbrook <rosbrookn@ainfosec.com>
> >
> > Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
> > ---
> > tools/golang/xenlight/gengotypes.py | 39 +++-
> > tools/golang/xenlight/helpers.gen.go | 300 +++++++++++++++++++++++++++
> > 2 files changed, 338 insertions(+), 1 deletion(-)
> >
> > diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
> > index b68c1aa66b..ee9aaf9eff 100644
> > --- a/tools/golang/xenlight/gengotypes.py
> > +++ b/tools/golang/xenlight/gengotypes.py
> > @@ -252,7 +252,7 @@ def xenlight_golang_define_from_C(ty = None):
> > for f in ty.fields:
> > if f.type.typename is not None:
> > if isinstance(f.type, idl.Array):
> > - # TODO
> > + body += xenlight_golang_array_from_C(f)
> > continue
> >
> > body += xenlight_golang_convert_from_C(f)
> > @@ -399,6 +399,43 @@ def xenlight_golang_union_from_C(ty = None, union_name = '', struct_name = ''):
> >
> > return (s,extras)
> >
> > +def xenlight_golang_array_from_C(ty = None):
> > + """
> > + Convert C array to Go slice using the method
> > + described here:
> > +
> > + https://github.com/golang/go/wiki/cgo#turning-c-arrays-into-go-slices
> > + """
> > + s = ''
> > +
> > + gotypename = xenlight_golang_fmt_name(ty.type.elem_type.typename)
> > + goname = xenlight_golang_fmt_name(ty.name)
> > + ctypename = ty.type.elem_type.typename
> > + cname = ty.name
> > + cslice = 'c{}'.format(goname)
> > + clenvar = ty.type.lenvar.name
> > + golenvar = xenlight_golang_fmt_name(clenvar,exported=False)
> > +
> > + s += '{} := int(xc.{})\n'.format(golenvar, clenvar)
> > + s += '{} := '.format(cslice)
> > + s +='(*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.format(ctypename, cname,
> > + golenvar, golenvar)
> > + s += 'x.{} = make([]{}, {})\n'.format(goname, gotypename, golenvar)
> > + s += 'for i, v := range {} {{\n'.format(cslice)
> > +
> > + is_enum = isinstance(ty.type.elem_type,idl.Enumeration)
> > + if gotypename in go_builtin_types or is_enum:
> > + s += 'x.{}[i] = {}(v)\n'.format(goname, gotypename)
> > + else:
> > + s += 'var e {}\n'.format(gotypename)
> > + s += 'if err := e.fromC(&v); err != nil {\n'
> > + s += 'return err }\n'
> > + s += 'x.{}[i] = e\n'.format(goname)
> > +
> > + s += '}\n'
> > +
> > + return s
> > +
> > def xenlight_golang_fmt_name(name, exported = True):
> > """
> > Take a given type name and return an
> > diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go
> > index e6eee234c0..2f917cac58 100644
> > --- a/tools/golang/xenlight/helpers.gen.go
> > +++ b/tools/golang/xenlight/helpers.gen.go
> > @@ -263,6 +263,16 @@ func (x *SchedParams) fromC(xc *C.libxl_sched_params) error {
> >
> > func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
> > x.Sched = Scheduler(xc.sched)
> > + numVcpus := int(xc.num_vcpus)
> > + cVcpus := (*[1 << 28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:numVcpus:numVcpus]
> > + x.Vcpus = make([]SchedParams, numVcpus)
> > + for i, v := range cVcpus {
> > + var e SchedParams
> > + if err := e.fromC(&v); err != nil {
> > + return err
> > + }
> > + x.Vcpus[i] = e
>
> Along the same lines, any reason not to do the following?
>
> if err := x.Vcpus[i].fromC(&v); err != nil {
> return err
> }
Nope, no problem with that.
Thanks,
-NR
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 33+ messages in thread
* [Xen-devel] [PATCH v3 18/22] golang/xenlight: begin Go to C type marshaling
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (16 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 17/22] golang/xenlight: implement array " Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 19/22] golang/xenlight: implement keyed union Go to C marshaling Nick Rosbrook
` (3 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Implement conversion of basic type conversions such as strings
and integer types in toC functions.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
tools/golang/xenlight/gengotypes.py | 80 ++
tools/golang/xenlight/helpers.gen.go | 1015 ++++++++++++++++++++++++++
2 files changed, 1095 insertions(+)
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
index ee9aaf9eff..cb9b18218f 100644
--- a/tools/golang/xenlight/gengotypes.py
+++ b/tools/golang/xenlight/gengotypes.py
@@ -234,6 +234,9 @@ def xenlight_golang_generate_helpers(path = None, types = None, comment = None):
f.write(extra)
f.write('\n')
+ f.write(xenlight_golang_define_to_C(ty))
+ f.write('\n')
+
go_fmt(path)
def xenlight_golang_define_from_C(ty = None):
@@ -436,6 +439,83 @@ def xenlight_golang_array_from_C(ty = None):
return s
+def xenlight_golang_define_to_C(ty = None, typename = None, nested = False):
+ s = ''
+
+ gotypename = ctypename = ''
+
+ if typename is not None:
+ gotypename = xenlight_golang_fmt_name(typename)
+ ctypename = typename
+ else:
+ gotypename = xenlight_golang_fmt_name(ty.typename)
+ ctypename = ty.typename
+
+ if not nested:
+ s += 'func (x *{}) toC() (xc C.{},err error) {{\n'.format(gotypename,ctypename)
+ s += 'C.{}(&xc)\n'.format(ty.init_fn)
+
+ for f in ty.fields:
+ if f.type.typename is not None:
+ if isinstance(f.type, idl.Array):
+ # TODO
+ continue
+
+ gotypename = xenlight_golang_fmt_name(f.type.typename)
+ ctypename = f.type.typename
+ gofname = xenlight_golang_fmt_name(f.name)
+ cfname = f.name
+
+ # In cgo, C names that conflict with Go keywords can be
+ # accessed by prepending an underscore to the name.
+ if cfname in go_keywords:
+ cfname = '_' + cfname
+
+ # If this is nested, we need the outer name too.
+ if nested and typename is not None:
+ goname = xenlight_golang_fmt_name(typename)
+ goname = '{}.{}'.format(goname, gofname)
+ cname = '{}.{}'.format(typename, cfname)
+
+ else:
+ goname = gofname
+ cname = cfname
+
+ is_castable = (f.type.json_parse_type == 'JSON_INTEGER' or
+ isinstance(f.type, idl.Enumeration) or
+ gotypename in go_builtin_types)
+
+ if is_castable:
+ # Use the cgo helper for converting C strings.
+ if gotypename == 'string':
+ s += 'xc.{} = C.CString(x.{})\n'.format(cname,goname)
+ continue
+
+ s += 'xc.{} = C.{}(x.{})\n'.format(cname,ctypename,goname)
+
+ else:
+ s += 'xc.{}, err = x.{}.toC()\n'.format(cname,goname)
+ s += 'if err != nil {\n'
+ s += 'C.{}(&xc)\n'.format(ty.dispose_fn)
+ s += 'return xc, err\n'
+ s += '}\n'
+
+ elif isinstance(f.type, idl.Struct):
+ s += xenlight_golang_define_to_C(f.type, typename=f.name, nested=True)
+
+ elif isinstance(f.type, idl.KeyedUnion):
+ # TODO
+ pass
+
+ else:
+ raise Exception('type {} not supported'.format(f.type))
+
+ if not nested:
+ s += 'return xc, nil'
+ s += '}\n'
+
+ return s
+
def xenlight_golang_fmt_name(name, exported = True):
"""
Take a given type name and return an
diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go
index 2f917cac58..a155b091a7 100644
--- a/tools/golang/xenlight/helpers.gen.go
+++ b/tools/golang/xenlight/helpers.gen.go
@@ -37,6 +37,13 @@ func (x *IoportRange) fromC(xc *C.libxl_ioport_range) error {
return nil
}
+func (x *IoportRange) toC() (xc C.libxl_ioport_range, err error) {
+ C.libxl_ioport_range_init(&xc)
+ xc.first = C.uint32_t(x.First)
+ xc.number = C.uint32_t(x.Number)
+ return xc, nil
+}
+
func (x *IomemRange) fromC(xc *C.libxl_iomem_range) error {
x.Start = uint64(xc.start)
x.Number = uint64(xc.number)
@@ -45,12 +52,26 @@ func (x *IomemRange) fromC(xc *C.libxl_iomem_range) error {
return nil
}
+func (x *IomemRange) toC() (xc C.libxl_iomem_range, err error) {
+ C.libxl_iomem_range_init(&xc)
+ xc.start = C.uint64_t(x.Start)
+ xc.number = C.uint64_t(x.Number)
+ xc.gfn = C.uint64_t(x.Gfn)
+ return xc, nil
+}
+
func (x *VgaInterfaceInfo) fromC(xc *C.libxl_vga_interface_info) error {
x.Kind = VgaInterfaceType(xc.kind)
return nil
}
+func (x *VgaInterfaceInfo) toC() (xc C.libxl_vga_interface_info, err error) {
+ C.libxl_vga_interface_info_init(&xc)
+ xc.kind = C.libxl_vga_interface_type(x.Kind)
+ return xc, nil
+}
+
func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error {
if err := x.Enable.fromC(&xc.enable); err != nil {
return err
@@ -65,6 +86,24 @@ func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error {
return nil
}
+func (x *VncInfo) toC() (xc C.libxl_vnc_info, err error) {
+ C.libxl_vnc_info_init(&xc)
+ xc.enable, err = x.Enable.toC()
+ if err != nil {
+ C.libxl_vnc_info_dispose(&xc)
+ return xc, err
+ }
+ xc.listen = C.CString(x.Listen)
+ xc.passwd = C.CString(x.Passwd)
+ xc.display = C.int(x.Display)
+ xc.findunused, err = x.Findunused.toC()
+ if err != nil {
+ C.libxl_vnc_info_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error {
if err := x.Enable.fromC(&xc.enable); err != nil {
return err
@@ -92,6 +131,43 @@ func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error {
return nil
}
+func (x *SpiceInfo) toC() (xc C.libxl_spice_info, err error) {
+ C.libxl_spice_info_init(&xc)
+ xc.enable, err = x.Enable.toC()
+ if err != nil {
+ C.libxl_spice_info_dispose(&xc)
+ return xc, err
+ }
+ xc.port = C.int(x.Port)
+ xc.tls_port = C.int(x.TlsPort)
+ xc.host = C.CString(x.Host)
+ xc.disable_ticketing, err = x.DisableTicketing.toC()
+ if err != nil {
+ C.libxl_spice_info_dispose(&xc)
+ return xc, err
+ }
+ xc.passwd = C.CString(x.Passwd)
+ xc.agent_mouse, err = x.AgentMouse.toC()
+ if err != nil {
+ C.libxl_spice_info_dispose(&xc)
+ return xc, err
+ }
+ xc.vdagent, err = x.Vdagent.toC()
+ if err != nil {
+ C.libxl_spice_info_dispose(&xc)
+ return xc, err
+ }
+ xc.clipboard_sharing, err = x.ClipboardSharing.toC()
+ if err != nil {
+ C.libxl_spice_info_dispose(&xc)
+ return xc, err
+ }
+ xc.usbredirection = C.int(x.Usbredirection)
+ xc.image_compression = C.CString(x.ImageCompression)
+ xc.streaming_video = C.CString(x.StreamingVideo)
+ return xc, nil
+}
+
func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error {
if err := x.Enable.fromC(&xc.enable); err != nil {
return err
@@ -105,6 +181,23 @@ func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error {
return nil
}
+func (x *SdlInfo) toC() (xc C.libxl_sdl_info, err error) {
+ C.libxl_sdl_info_init(&xc)
+ xc.enable, err = x.Enable.toC()
+ if err != nil {
+ C.libxl_sdl_info_dispose(&xc)
+ return xc, err
+ }
+ xc.opengl, err = x.Opengl.toC()
+ if err != nil {
+ C.libxl_sdl_info_dispose(&xc)
+ return xc, err
+ }
+ xc.display = C.CString(x.Display)
+ xc.xauthority = C.CString(x.Xauthority)
+ return xc, nil
+}
+
func (x *Dominfo) fromC(xc *C.libxl_dominfo) error {
if err := x.Uuid.fromC(&xc.uuid); err != nil {
return err
@@ -133,6 +226,36 @@ func (x *Dominfo) fromC(xc *C.libxl_dominfo) error {
return nil
}
+func (x *Dominfo) toC() (xc C.libxl_dominfo, err error) {
+ C.libxl_dominfo_init(&xc)
+ xc.uuid, err = x.Uuid.toC()
+ if err != nil {
+ C.libxl_dominfo_dispose(&xc)
+ return xc, err
+ }
+ xc.domid = C.libxl_domid(x.Domid)
+ xc.ssidref = C.uint32_t(x.Ssidref)
+ xc.ssid_label = C.CString(x.SsidLabel)
+ xc.running = C.bool(x.Running)
+ xc.blocked = C.bool(x.Blocked)
+ xc.paused = C.bool(x.Paused)
+ xc.shutdown = C.bool(x.Shutdown)
+ xc.dying = C.bool(x.Dying)
+ xc.never_stop = C.bool(x.NeverStop)
+ xc.shutdown_reason = C.libxl_shutdown_reason(x.ShutdownReason)
+ xc.outstanding_memkb = C.uint64_t(x.OutstandingMemkb)
+ xc.current_memkb = C.uint64_t(x.CurrentMemkb)
+ xc.shared_memkb = C.uint64_t(x.SharedMemkb)
+ xc.paged_memkb = C.uint64_t(x.PagedMemkb)
+ xc.max_memkb = C.uint64_t(x.MaxMemkb)
+ xc.cpu_time = C.uint64_t(x.CpuTime)
+ xc.vcpu_max_id = C.uint32_t(x.VcpuMaxId)
+ xc.vcpu_online = C.uint32_t(x.VcpuOnline)
+ xc.cpupool = C.uint32_t(x.Cpupool)
+ xc.domain_type = C.libxl_domain_type(x.DomainType)
+ return xc, nil
+}
+
func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) error {
x.Poolid = uint32(xc.poolid)
x.PoolName = C.GoString(xc.pool_name)
@@ -145,6 +268,20 @@ func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) error {
return nil
}
+func (x *Cpupoolinfo) toC() (xc C.libxl_cpupoolinfo, err error) {
+ C.libxl_cpupoolinfo_init(&xc)
+ xc.poolid = C.uint32_t(x.Poolid)
+ xc.pool_name = C.CString(x.PoolName)
+ xc.sched = C.libxl_scheduler(x.Sched)
+ xc.n_dom = C.uint32_t(x.NDom)
+ xc.cpumap, err = x.Cpumap.toC()
+ if err != nil {
+ C.libxl_cpupoolinfo_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *Channelinfo) fromC(xc *C.libxl_channelinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -179,6 +316,19 @@ func (x *ChannelinfoConnectionUnionPty) fromC(xc *C.libxl_channelinfo) error {
return nil
}
+func (x *Channelinfo) toC() (xc C.libxl_channelinfo, err error) {
+ C.libxl_channelinfo_init(&xc)
+ xc.backend = C.CString(x.Backend)
+ xc.backend_id = C.uint32_t(x.BackendId)
+ xc.frontend = C.CString(x.Frontend)
+ xc.frontend_id = C.uint32_t(x.FrontendId)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.state = C.int(x.State)
+ xc.evtch = C.int(x.Evtch)
+ xc.rref = C.int(x.Rref)
+ return xc, nil
+}
+
func (x *Vminfo) fromC(xc *C.libxl_vminfo) error {
if err := x.Uuid.fromC(&xc.uuid); err != nil {
return err
@@ -188,6 +338,17 @@ func (x *Vminfo) fromC(xc *C.libxl_vminfo) error {
return nil
}
+func (x *Vminfo) toC() (xc C.libxl_vminfo, err error) {
+ C.libxl_vminfo_init(&xc)
+ xc.uuid, err = x.Uuid.toC()
+ if err != nil {
+ C.libxl_vminfo_dispose(&xc)
+ return xc, err
+ }
+ xc.domid = C.libxl_domid(x.Domid)
+ return xc, nil
+}
+
func (x *VersionInfo) fromC(xc *C.libxl_version_info) error {
x.XenVersionMajor = int(xc.xen_version_major)
x.XenVersionMinor = int(xc.xen_version_minor)
@@ -206,6 +367,24 @@ func (x *VersionInfo) fromC(xc *C.libxl_version_info) error {
return nil
}
+func (x *VersionInfo) toC() (xc C.libxl_version_info, err error) {
+ C.libxl_version_info_init(&xc)
+ xc.xen_version_major = C.int(x.XenVersionMajor)
+ xc.xen_version_minor = C.int(x.XenVersionMinor)
+ xc.xen_version_extra = C.CString(x.XenVersionExtra)
+ xc.compiler = C.CString(x.Compiler)
+ xc.compile_by = C.CString(x.CompileBy)
+ xc.compile_domain = C.CString(x.CompileDomain)
+ xc.compile_date = C.CString(x.CompileDate)
+ xc.capabilities = C.CString(x.Capabilities)
+ xc.changeset = C.CString(x.Changeset)
+ xc.virt_start = C.uint64_t(x.VirtStart)
+ xc.pagesize = C.int(x.Pagesize)
+ xc.commandline = C.CString(x.Commandline)
+ xc.build_id = C.CString(x.BuildId)
+ return xc, nil
+}
+
func (x *DomainCreateInfo) fromC(xc *C.libxl_domain_create_info) error {
x.Type = DomainType(xc._type)
if err := x.Hap.fromC(&xc.hap); err != nil {
@@ -239,6 +418,53 @@ func (x *DomainCreateInfo) fromC(xc *C.libxl_domain_create_info) error {
return nil
}
+func (x *DomainCreateInfo) toC() (xc C.libxl_domain_create_info, err error) {
+ C.libxl_domain_create_info_init(&xc)
+ xc._type = C.libxl_domain_type(x.Type)
+ xc.hap, err = x.Hap.toC()
+ if err != nil {
+ C.libxl_domain_create_info_dispose(&xc)
+ return xc, err
+ }
+ xc.oos, err = x.Oos.toC()
+ if err != nil {
+ C.libxl_domain_create_info_dispose(&xc)
+ return xc, err
+ }
+ xc.ssidref = C.uint32_t(x.Ssidref)
+ xc.ssid_label = C.CString(x.SsidLabel)
+ xc.name = C.CString(x.Name)
+ xc.uuid, err = x.Uuid.toC()
+ if err != nil {
+ C.libxl_domain_create_info_dispose(&xc)
+ return xc, err
+ }
+ xc.xsdata, err = x.Xsdata.toC()
+ if err != nil {
+ C.libxl_domain_create_info_dispose(&xc)
+ return xc, err
+ }
+ xc.platformdata, err = x.Platformdata.toC()
+ if err != nil {
+ C.libxl_domain_create_info_dispose(&xc)
+ return xc, err
+ }
+ xc.poolid = C.uint32_t(x.Poolid)
+ xc.pool_name = C.CString(x.PoolName)
+ xc.run_hotplug_scripts, err = x.RunHotplugScripts.toC()
+ if err != nil {
+ C.libxl_domain_create_info_dispose(&xc)
+ return xc, err
+ }
+ xc.driver_domain, err = x.DriverDomain.toC()
+ if err != nil {
+ C.libxl_domain_create_info_dispose(&xc)
+ return xc, err
+ }
+ xc.passthrough = C.libxl_passthrough(x.Passthrough)
+ return xc, nil
+}
+
func (x *DomainRestoreParams) fromC(xc *C.libxl_domain_restore_params) error {
x.CheckpointedStream = int(xc.checkpointed_stream)
x.StreamVersion = uint32(xc.stream_version)
@@ -250,6 +476,19 @@ func (x *DomainRestoreParams) fromC(xc *C.libxl_domain_restore_params) error {
return nil
}
+func (x *DomainRestoreParams) toC() (xc C.libxl_domain_restore_params, err error) {
+ C.libxl_domain_restore_params_init(&xc)
+ xc.checkpointed_stream = C.int(x.CheckpointedStream)
+ xc.stream_version = C.uint32_t(x.StreamVersion)
+ xc.colo_proxy_script = C.CString(x.ColoProxyScript)
+ xc.userspace_colo_proxy, err = x.UserspaceColoProxy.toC()
+ if err != nil {
+ C.libxl_domain_restore_params_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *SchedParams) fromC(xc *C.libxl_sched_params) error {
x.Vcpuid = int(xc.vcpuid)
x.Weight = int(xc.weight)
@@ -261,6 +500,17 @@ func (x *SchedParams) fromC(xc *C.libxl_sched_params) error {
return nil
}
+func (x *SchedParams) toC() (xc C.libxl_sched_params, err error) {
+ C.libxl_sched_params_init(&xc)
+ xc.vcpuid = C.int(x.Vcpuid)
+ xc.weight = C.int(x.Weight)
+ xc.cap = C.int(x.Cap)
+ xc.period = C.int(x.Period)
+ xc.extratime = C.int(x.Extratime)
+ xc.budget = C.int(x.Budget)
+ return xc, nil
+}
+
func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
x.Sched = Scheduler(xc.sched)
numVcpus := int(xc.num_vcpus)
@@ -277,6 +527,12 @@ func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
return nil
}
+func (x *VcpuSchedParams) toC() (xc C.libxl_vcpu_sched_params, err error) {
+ C.libxl_vcpu_sched_params_init(&xc)
+ xc.sched = C.libxl_scheduler(x.Sched)
+ return xc, nil
+}
+
func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error {
x.Sched = Scheduler(xc.sched)
x.Weight = int(xc.weight)
@@ -290,6 +546,19 @@ func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error {
return nil
}
+func (x *DomainSchedParams) toC() (xc C.libxl_domain_sched_params, err error) {
+ C.libxl_domain_sched_params_init(&xc)
+ xc.sched = C.libxl_scheduler(x.Sched)
+ xc.weight = C.int(x.Weight)
+ xc.cap = C.int(x.Cap)
+ xc.period = C.int(x.Period)
+ xc.budget = C.int(x.Budget)
+ xc.extratime = C.int(x.Extratime)
+ xc.slice = C.int(x.Slice)
+ xc.latency = C.int(x.Latency)
+ return xc, nil
+}
+
func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error {
x.Memkb = uint64(xc.memkb)
numDistances := int(xc.num_distances)
@@ -306,6 +575,18 @@ func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error {
return nil
}
+func (x *VnodeInfo) toC() (xc C.libxl_vnode_info, err error) {
+ C.libxl_vnode_info_init(&xc)
+ xc.memkb = C.uint64_t(x.Memkb)
+ xc.pnode = C.uint32_t(x.Pnode)
+ xc.vcpus, err = x.Vcpus.toC()
+ if err != nil {
+ C.libxl_vnode_info_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) error {
x.Strategy = RdmReserveStrategy(xc.strategy)
x.Policy = RdmReservePolicy(xc.policy)
@@ -313,6 +594,13 @@ func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) error {
return nil
}
+func (x *RdmReserve) toC() (xc C.libxl_rdm_reserve, err error) {
+ C.libxl_rdm_reserve_init(&xc)
+ xc.strategy = C.libxl_rdm_reserve_strategy(x.Strategy)
+ xc.policy = C.libxl_rdm_reserve_policy(x.Policy)
+ return xc, nil
+}
+
func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error {
x.MaxVcpus = int(xc.max_vcpus)
if err := x.AvailVcpus.fromC(&xc.avail_vcpus); err != nil {
@@ -625,6 +913,130 @@ func (x *DomainBuildInfoTypeUnionPvh) fromC(xc *C.libxl_domain_build_info) error
return nil
}
+func (x *DomainBuildInfo) toC() (xc C.libxl_domain_build_info, err error) {
+ C.libxl_domain_build_info_init(&xc)
+ xc.max_vcpus = C.int(x.MaxVcpus)
+ xc.avail_vcpus, err = x.AvailVcpus.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.cpumap, err = x.Cpumap.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.nodemap, err = x.Nodemap.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.numa_placement, err = x.NumaPlacement.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.tsc_mode = C.libxl_tsc_mode(x.TscMode)
+ xc.max_memkb = C.uint64_t(x.MaxMemkb)
+ xc.target_memkb = C.uint64_t(x.TargetMemkb)
+ xc.video_memkb = C.uint64_t(x.VideoMemkb)
+ xc.shadow_memkb = C.uint64_t(x.ShadowMemkb)
+ xc.iommu_memkb = C.uint64_t(x.IommuMemkb)
+ xc.rtc_timeoffset = C.uint32_t(x.RtcTimeoffset)
+ xc.exec_ssidref = C.uint32_t(x.ExecSsidref)
+ xc.exec_ssid_label = C.CString(x.ExecSsidLabel)
+ xc.localtime, err = x.Localtime.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.disable_migrate, err = x.DisableMigrate.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.cpuid, err = x.Cpuid.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.blkdev_start = C.CString(x.BlkdevStart)
+ xc.max_grant_frames = C.uint32_t(x.MaxGrantFrames)
+ xc.max_maptrack_frames = C.uint32_t(x.MaxMaptrackFrames)
+ xc.device_model_version = C.libxl_device_model_version(x.DeviceModelVersion)
+ xc.device_model_stubdomain, err = x.DeviceModelStubdomain.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.device_model = C.CString(x.DeviceModel)
+ xc.device_model_ssidref = C.uint32_t(x.DeviceModelSsidref)
+ xc.device_model_ssid_label = C.CString(x.DeviceModelSsidLabel)
+ xc.device_model_user = C.CString(x.DeviceModelUser)
+ xc.extra, err = x.Extra.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.extra_pv, err = x.ExtraPv.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.extra_hvm, err = x.ExtraHvm.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.sched_params, err = x.SchedParams.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.claim_mode, err = x.ClaimMode.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.event_channels = C.uint32_t(x.EventChannels)
+ xc.kernel = C.CString(x.Kernel)
+ xc.cmdline = C.CString(x.Cmdline)
+ xc.ramdisk = C.CString(x.Ramdisk)
+ xc.device_tree = C.CString(x.DeviceTree)
+ xc.acpi, err = x.Acpi.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.bootloader = C.CString(x.Bootloader)
+ xc.bootloader_args, err = x.BootloaderArgs.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.timer_mode = C.libxl_timer_mode(x.TimerMode)
+ xc.nested_hvm, err = x.NestedHvm.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.apic, err = x.Apic.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.dm_restrict, err = x.DmRestrict.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ xc.tee = C.libxl_tee_type(x.Tee)
+ xc.arch_arm.gic_version = C.libxl_gic_version(x.ArchArm.GicVersion)
+ xc.arch_arm.vuart = C.libxl_vuart_type(x.ArchArm.Vuart)
+ xc.altp2m = C.libxl_altp2m_mode(x.Altp2M)
+ return xc, nil
+}
+
func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -640,6 +1052,25 @@ func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) error {
return nil
}
+func (x *DeviceVfb) toC() (xc C.libxl_device_vfb, err error) {
+ C.libxl_device_vfb_init(&xc)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.vnc, err = x.Vnc.toC()
+ if err != nil {
+ C.libxl_device_vfb_dispose(&xc)
+ return xc, err
+ }
+ xc.sdl, err = x.Sdl.toC()
+ if err != nil {
+ C.libxl_device_vfb_dispose(&xc)
+ return xc, err
+ }
+ xc.keymap = C.CString(x.Keymap)
+ return xc, nil
+}
+
func (x *DeviceVkb) fromC(xc *C.libxl_device_vkb) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -660,6 +1091,26 @@ func (x *DeviceVkb) fromC(xc *C.libxl_device_vkb) error {
return nil
}
+func (x *DeviceVkb) toC() (xc C.libxl_device_vkb, err error) {
+ C.libxl_device_vkb_init(&xc)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.backend_type = C.libxl_vkb_backend(x.BackendType)
+ xc.unique_id = C.CString(x.UniqueId)
+ xc.feature_disable_keyboard = C.bool(x.FeatureDisableKeyboard)
+ xc.feature_disable_pointer = C.bool(x.FeatureDisablePointer)
+ xc.feature_abs_pointer = C.bool(x.FeatureAbsPointer)
+ xc.feature_raw_pointer = C.bool(x.FeatureRawPointer)
+ xc.feature_multi_touch = C.bool(x.FeatureMultiTouch)
+ xc.width = C.uint32_t(x.Width)
+ xc.height = C.uint32_t(x.Height)
+ xc.multi_touch_width = C.uint32_t(x.MultiTouchWidth)
+ xc.multi_touch_height = C.uint32_t(x.MultiTouchHeight)
+ xc.multi_touch_num_contacts = C.uint32_t(x.MultiTouchNumContacts)
+ return xc, nil
+}
+
func (x *DeviceDisk) fromC(xc *C.libxl_device_disk) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -690,6 +1141,42 @@ func (x *DeviceDisk) fromC(xc *C.libxl_device_disk) error {
return nil
}
+func (x *DeviceDisk) toC() (xc C.libxl_device_disk, err error) {
+ C.libxl_device_disk_init(&xc)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ xc.pdev_path = C.CString(x.PdevPath)
+ xc.vdev = C.CString(x.Vdev)
+ xc.backend = C.libxl_disk_backend(x.Backend)
+ xc.format = C.libxl_disk_format(x.Format)
+ xc.script = C.CString(x.Script)
+ xc.removable = C.int(x.Removable)
+ xc.readwrite = C.int(x.Readwrite)
+ xc.is_cdrom = C.int(x.IsCdrom)
+ xc.direct_io_safe = C.bool(x.DirectIoSafe)
+ xc.discard_enable, err = x.DiscardEnable.toC()
+ if err != nil {
+ C.libxl_device_disk_dispose(&xc)
+ return xc, err
+ }
+ xc.colo_enable, err = x.ColoEnable.toC()
+ if err != nil {
+ C.libxl_device_disk_dispose(&xc)
+ return xc, err
+ }
+ xc.colo_restore_enable, err = x.ColoRestoreEnable.toC()
+ if err != nil {
+ C.libxl_device_disk_dispose(&xc)
+ return xc, err
+ }
+ xc.colo_host = C.CString(x.ColoHost)
+ xc.colo_port = C.int(x.ColoPort)
+ xc.colo_export = C.CString(x.ColoExport)
+ xc.active_disk = C.CString(x.ActiveDisk)
+ xc.hidden_disk = C.CString(x.HiddenDisk)
+ return xc, nil
+}
+
func (x *DeviceNic) fromC(xc *C.libxl_device_nic) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -760,6 +1247,78 @@ func (x *DeviceNic) fromC(xc *C.libxl_device_nic) error {
return nil
}
+func (x *DeviceNic) toC() (xc C.libxl_device_nic, err error) {
+ C.libxl_device_nic_init(&xc)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.mtu = C.int(x.Mtu)
+ xc.model = C.CString(x.Model)
+ xc.mac, err = x.Mac.toC()
+ if err != nil {
+ C.libxl_device_nic_dispose(&xc)
+ return xc, err
+ }
+ xc.ip = C.CString(x.Ip)
+ xc.bridge = C.CString(x.Bridge)
+ xc.ifname = C.CString(x.Ifname)
+ xc.script = C.CString(x.Script)
+ xc.nictype = C.libxl_nic_type(x.Nictype)
+ xc.rate_bytes_per_interval = C.uint64_t(x.RateBytesPerInterval)
+ xc.rate_interval_usecs = C.uint32_t(x.RateIntervalUsecs)
+ xc.gatewaydev = C.CString(x.Gatewaydev)
+ xc.coloft_forwarddev = C.CString(x.ColoftForwarddev)
+ xc.colo_sock_mirror_id = C.CString(x.ColoSockMirrorId)
+ xc.colo_sock_mirror_ip = C.CString(x.ColoSockMirrorIp)
+ xc.colo_sock_mirror_port = C.CString(x.ColoSockMirrorPort)
+ xc.colo_sock_compare_pri_in_id = C.CString(x.ColoSockComparePriInId)
+ xc.colo_sock_compare_pri_in_ip = C.CString(x.ColoSockComparePriInIp)
+ xc.colo_sock_compare_pri_in_port = C.CString(x.ColoSockComparePriInPort)
+ xc.colo_sock_compare_sec_in_id = C.CString(x.ColoSockCompareSecInId)
+ xc.colo_sock_compare_sec_in_ip = C.CString(x.ColoSockCompareSecInIp)
+ xc.colo_sock_compare_sec_in_port = C.CString(x.ColoSockCompareSecInPort)
+ xc.colo_sock_compare_notify_id = C.CString(x.ColoSockCompareNotifyId)
+ xc.colo_sock_compare_notify_ip = C.CString(x.ColoSockCompareNotifyIp)
+ xc.colo_sock_compare_notify_port = C.CString(x.ColoSockCompareNotifyPort)
+ xc.colo_sock_redirector0_id = C.CString(x.ColoSockRedirector0Id)
+ xc.colo_sock_redirector0_ip = C.CString(x.ColoSockRedirector0Ip)
+ xc.colo_sock_redirector0_port = C.CString(x.ColoSockRedirector0Port)
+ xc.colo_sock_redirector1_id = C.CString(x.ColoSockRedirector1Id)
+ xc.colo_sock_redirector1_ip = C.CString(x.ColoSockRedirector1Ip)
+ xc.colo_sock_redirector1_port = C.CString(x.ColoSockRedirector1Port)
+ xc.colo_sock_redirector2_id = C.CString(x.ColoSockRedirector2Id)
+ xc.colo_sock_redirector2_ip = C.CString(x.ColoSockRedirector2Ip)
+ xc.colo_sock_redirector2_port = C.CString(x.ColoSockRedirector2Port)
+ xc.colo_filter_mirror_queue = C.CString(x.ColoFilterMirrorQueue)
+ xc.colo_filter_mirror_outdev = C.CString(x.ColoFilterMirrorOutdev)
+ xc.colo_filter_redirector0_queue = C.CString(x.ColoFilterRedirector0Queue)
+ xc.colo_filter_redirector0_indev = C.CString(x.ColoFilterRedirector0Indev)
+ xc.colo_filter_redirector0_outdev = C.CString(x.ColoFilterRedirector0Outdev)
+ xc.colo_filter_redirector1_queue = C.CString(x.ColoFilterRedirector1Queue)
+ xc.colo_filter_redirector1_indev = C.CString(x.ColoFilterRedirector1Indev)
+ xc.colo_filter_redirector1_outdev = C.CString(x.ColoFilterRedirector1Outdev)
+ xc.colo_compare_pri_in = C.CString(x.ColoComparePriIn)
+ xc.colo_compare_sec_in = C.CString(x.ColoCompareSecIn)
+ xc.colo_compare_out = C.CString(x.ColoCompareOut)
+ xc.colo_compare_notify_dev = C.CString(x.ColoCompareNotifyDev)
+ xc.colo_sock_sec_redirector0_id = C.CString(x.ColoSockSecRedirector0Id)
+ xc.colo_sock_sec_redirector0_ip = C.CString(x.ColoSockSecRedirector0Ip)
+ xc.colo_sock_sec_redirector0_port = C.CString(x.ColoSockSecRedirector0Port)
+ xc.colo_sock_sec_redirector1_id = C.CString(x.ColoSockSecRedirector1Id)
+ xc.colo_sock_sec_redirector1_ip = C.CString(x.ColoSockSecRedirector1Ip)
+ xc.colo_sock_sec_redirector1_port = C.CString(x.ColoSockSecRedirector1Port)
+ xc.colo_filter_sec_redirector0_queue = C.CString(x.ColoFilterSecRedirector0Queue)
+ xc.colo_filter_sec_redirector0_indev = C.CString(x.ColoFilterSecRedirector0Indev)
+ xc.colo_filter_sec_redirector0_outdev = C.CString(x.ColoFilterSecRedirector0Outdev)
+ xc.colo_filter_sec_redirector1_queue = C.CString(x.ColoFilterSecRedirector1Queue)
+ xc.colo_filter_sec_redirector1_indev = C.CString(x.ColoFilterSecRedirector1Indev)
+ xc.colo_filter_sec_redirector1_outdev = C.CString(x.ColoFilterSecRedirector1Outdev)
+ xc.colo_filter_sec_rewriter0_queue = C.CString(x.ColoFilterSecRewriter0Queue)
+ xc.colo_checkpoint_host = C.CString(x.ColoCheckpointHost)
+ xc.colo_checkpoint_port = C.CString(x.ColoCheckpointPort)
+ return xc, nil
+}
+
func (x *DevicePci) fromC(xc *C.libxl_device_pci) error {
x.Func = byte(xc._func)
x.Dev = byte(xc.dev)
@@ -776,6 +1335,22 @@ func (x *DevicePci) fromC(xc *C.libxl_device_pci) error {
return nil
}
+func (x *DevicePci) toC() (xc C.libxl_device_pci, err error) {
+ C.libxl_device_pci_init(&xc)
+ xc._func = C.uint8_t(x.Func)
+ xc.dev = C.uint8_t(x.Dev)
+ xc.bus = C.uint8_t(x.Bus)
+ xc.domain = C.int(x.Domain)
+ xc.vdevfn = C.uint32_t(x.Vdevfn)
+ xc.vfunc_mask = C.uint32_t(x.VfuncMask)
+ xc.msitranslate = C.bool(x.Msitranslate)
+ xc.power_mgmt = C.bool(x.PowerMgmt)
+ xc.permissive = C.bool(x.Permissive)
+ xc.seize = C.bool(x.Seize)
+ xc.rdm_policy = C.libxl_rdm_reserve_policy(x.RdmPolicy)
+ return xc, nil
+}
+
func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) error {
x.Start = uint64(xc.start)
x.Size = uint64(xc.size)
@@ -784,6 +1359,14 @@ func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) error {
return nil
}
+func (x *DeviceRdm) toC() (xc C.libxl_device_rdm, err error) {
+ C.libxl_device_rdm_init(&xc)
+ xc.start = C.uint64_t(x.Start)
+ xc.size = C.uint64_t(x.Size)
+ xc.policy = C.libxl_rdm_reserve_policy(x.Policy)
+ return xc, nil
+}
+
func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error {
x.Type = UsbctrlType(xc._type)
x.Devid = Devid(xc.devid)
@@ -795,6 +1378,17 @@ func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error {
return nil
}
+func (x *DeviceUsbctrl) toC() (xc C.libxl_device_usbctrl, err error) {
+ C.libxl_device_usbctrl_init(&xc)
+ xc._type = C.libxl_usbctrl_type(x.Type)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.version = C.int(x.Version)
+ xc.ports = C.int(x.Ports)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ return xc, nil
+}
+
func (x *DeviceUsbdev) fromC(xc *C.libxl_device_usbdev) error {
x.Ctrl = Devid(xc.ctrl)
x.Port = int(xc.port)
@@ -824,12 +1418,25 @@ func (x *DeviceUsbdevTypeUnionHostdev) fromC(xc *C.libxl_device_usbdev) error {
return nil
}
+func (x *DeviceUsbdev) toC() (xc C.libxl_device_usbdev, err error) {
+ C.libxl_device_usbdev_init(&xc)
+ xc.ctrl = C.libxl_devid(x.Ctrl)
+ xc.port = C.int(x.Port)
+ return xc, nil
+}
+
func (x *DeviceDtdev) fromC(xc *C.libxl_device_dtdev) error {
x.Path = C.GoString(xc.path)
return nil
}
+func (x *DeviceDtdev) toC() (xc C.libxl_device_dtdev, err error) {
+ C.libxl_device_dtdev_init(&xc)
+ xc.path = C.CString(x.Path)
+ return xc, nil
+}
+
func (x *DeviceVtpm) fromC(xc *C.libxl_device_vtpm) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -841,6 +1448,19 @@ func (x *DeviceVtpm) fromC(xc *C.libxl_device_vtpm) error {
return nil
}
+func (x *DeviceVtpm) toC() (xc C.libxl_device_vtpm, err error) {
+ C.libxl_device_vtpm_init(&xc)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.uuid, err = x.Uuid.toC()
+ if err != nil {
+ C.libxl_device_vtpm_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -852,6 +1472,17 @@ func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error {
return nil
}
+func (x *DeviceP9) toC() (xc C.libxl_device_p9, err error) {
+ C.libxl_device_p9_init(&xc)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ xc.tag = C.CString(x.Tag)
+ xc.path = C.CString(x.Path)
+ xc.security_model = C.CString(x.SecurityModel)
+ xc.devid = C.libxl_devid(x.Devid)
+ return xc, nil
+}
+
func (x *DevicePvcallsif) fromC(xc *C.libxl_device_pvcallsif) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -860,6 +1491,14 @@ func (x *DevicePvcallsif) fromC(xc *C.libxl_device_pvcallsif) error {
return nil
}
+func (x *DevicePvcallsif) toC() (xc C.libxl_device_pvcallsif, err error) {
+ C.libxl_device_pvcallsif_init(&xc)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ xc.devid = C.libxl_devid(x.Devid)
+ return xc, nil
+}
+
func (x *DeviceChannel) fromC(xc *C.libxl_device_channel) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -890,6 +1529,15 @@ func (x *DeviceChannelConnectionUnionSocket) fromC(xc *C.libxl_device_channel) e
return nil
}
+func (x *DeviceChannel) toC() (xc C.libxl_device_channel, err error) {
+ C.libxl_device_channel_init(&xc)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.name = C.CString(x.Name)
+ return xc, nil
+}
+
func (x *ConnectorParam) fromC(xc *C.libxl_connector_param) error {
x.UniqueId = C.GoString(xc.unique_id)
x.Width = uint32(xc.width)
@@ -898,6 +1546,14 @@ func (x *ConnectorParam) fromC(xc *C.libxl_connector_param) error {
return nil
}
+func (x *ConnectorParam) toC() (xc C.libxl_connector_param, err error) {
+ C.libxl_connector_param_init(&xc)
+ xc.unique_id = C.CString(x.UniqueId)
+ xc.width = C.uint32_t(x.Width)
+ xc.height = C.uint32_t(x.Height)
+ return xc, nil
+}
+
func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdispl) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -917,6 +1573,15 @@ func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdispl) error {
return nil
}
+func (x *DeviceVdispl) toC() (xc C.libxl_device_vdispl, err error) {
+ C.libxl_device_vdispl_init(&xc)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.be_alloc = C.bool(x.BeAlloc)
+ return xc, nil
+}
+
func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error {
numSampleRates := int(xc.num_sample_rates)
cSampleRates := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.sample_rates))[:numSampleRates:numSampleRates]
@@ -937,6 +1602,14 @@ func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error {
return nil
}
+func (x *VsndParams) toC() (xc C.libxl_vsnd_params, err error) {
+ C.libxl_vsnd_params_init(&xc)
+ xc.channels_min = C.uint32_t(x.ChannelsMin)
+ xc.channels_max = C.uint32_t(x.ChannelsMax)
+ xc.buffer_size = C.uint32_t(x.BufferSize)
+ return xc, nil
+}
+
func (x *VsndStream) fromC(xc *C.libxl_vsnd_stream) error {
x.UniqueId = C.GoString(xc.unique_id)
x.Type = VsndStreamType(xc._type)
@@ -947,6 +1620,18 @@ func (x *VsndStream) fromC(xc *C.libxl_vsnd_stream) error {
return nil
}
+func (x *VsndStream) toC() (xc C.libxl_vsnd_stream, err error) {
+ C.libxl_vsnd_stream_init(&xc)
+ xc.unique_id = C.CString(x.UniqueId)
+ xc._type = C.libxl_vsnd_stream_type(x.Type)
+ xc.params, err = x.Params.toC()
+ if err != nil {
+ C.libxl_vsnd_stream_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error {
x.Name = C.GoString(xc.name)
if err := x.Params.fromC(&xc.params); err != nil {
@@ -966,6 +1651,17 @@ func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error {
return nil
}
+func (x *VsndPcm) toC() (xc C.libxl_vsnd_pcm, err error) {
+ C.libxl_vsnd_pcm_init(&xc)
+ xc.name = C.CString(x.Name)
+ xc.params, err = x.Params.toC()
+ if err != nil {
+ C.libxl_vsnd_pcm_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -989,6 +1685,21 @@ func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error {
return nil
}
+func (x *DeviceVsnd) toC() (xc C.libxl_device_vsnd, err error) {
+ C.libxl_device_vsnd_init(&xc)
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ xc.backend_domname = C.CString(x.BackendDomname)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.short_name = C.CString(x.ShortName)
+ xc.long_name = C.CString(x.LongName)
+ xc.params, err = x.Params.toC()
+ if err != nil {
+ C.libxl_device_vsnd_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error {
if err := x.CInfo.fromC(&xc.c_info); err != nil {
return err
@@ -1155,6 +1866,26 @@ func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error {
return nil
}
+func (x *DomainConfig) toC() (xc C.libxl_domain_config, err error) {
+ C.libxl_domain_config_init(&xc)
+ xc.c_info, err = x.CInfo.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ xc.b_info, err = x.BInfo.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ xc.on_poweroff = C.libxl_action_on_shutdown(x.OnPoweroff)
+ xc.on_reboot = C.libxl_action_on_shutdown(x.OnReboot)
+ xc.on_watchdog = C.libxl_action_on_shutdown(x.OnWatchdog)
+ xc.on_crash = C.libxl_action_on_shutdown(x.OnCrash)
+ xc.on_soft_reset = C.libxl_action_on_shutdown(x.OnSoftReset)
+ return xc, nil
+}
+
func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1168,6 +1899,19 @@ func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error {
return nil
}
+func (x *Diskinfo) toC() (xc C.libxl_diskinfo, err error) {
+ C.libxl_diskinfo_init(&xc)
+ xc.backend = C.CString(x.Backend)
+ xc.backend_id = C.uint32_t(x.BackendId)
+ xc.frontend = C.CString(x.Frontend)
+ xc.frontend_id = C.uint32_t(x.FrontendId)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.state = C.int(x.State)
+ xc.evtch = C.int(x.Evtch)
+ xc.rref = C.int(x.Rref)
+ return xc, nil
+}
+
func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1182,6 +1926,20 @@ func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error {
return nil
}
+func (x *Nicinfo) toC() (xc C.libxl_nicinfo, err error) {
+ C.libxl_nicinfo_init(&xc)
+ xc.backend = C.CString(x.Backend)
+ xc.backend_id = C.uint32_t(x.BackendId)
+ xc.frontend = C.CString(x.Frontend)
+ xc.frontend_id = C.uint32_t(x.FrontendId)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.state = C.int(x.State)
+ xc.evtch = C.int(x.Evtch)
+ xc.rref_tx = C.int(x.RrefTx)
+ xc.rref_rx = C.int(x.RrefRx)
+ return xc, nil
+}
+
func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1198,6 +1956,24 @@ func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error {
return nil
}
+func (x *Vtpminfo) toC() (xc C.libxl_vtpminfo, err error) {
+ C.libxl_vtpminfo_init(&xc)
+ xc.backend = C.CString(x.Backend)
+ xc.backend_id = C.uint32_t(x.BackendId)
+ xc.frontend = C.CString(x.Frontend)
+ xc.frontend_id = C.uint32_t(x.FrontendId)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.state = C.int(x.State)
+ xc.evtch = C.int(x.Evtch)
+ xc.rref = C.int(x.Rref)
+ xc.uuid, err = x.Uuid.toC()
+ if err != nil {
+ C.libxl_vtpminfo_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo) error {
x.Type = UsbctrlType(xc._type)
x.Devid = Devid(xc.devid)
@@ -1215,6 +1991,23 @@ func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo) error {
return nil
}
+func (x *Usbctrlinfo) toC() (xc C.libxl_usbctrlinfo, err error) {
+ C.libxl_usbctrlinfo_init(&xc)
+ xc._type = C.libxl_usbctrl_type(x.Type)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.version = C.int(x.Version)
+ xc.ports = C.int(x.Ports)
+ xc.backend = C.CString(x.Backend)
+ xc.backend_id = C.uint32_t(x.BackendId)
+ xc.frontend = C.CString(x.Frontend)
+ xc.frontend_id = C.uint32_t(x.FrontendId)
+ xc.state = C.int(x.State)
+ xc.evtch = C.int(x.Evtch)
+ xc.ref_urb = C.int(x.RefUrb)
+ xc.ref_conn = C.int(x.RefConn)
+ return xc, nil
+}
+
func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error {
x.Vcpuid = uint32(xc.vcpuid)
x.Cpu = uint32(xc.cpu)
@@ -1232,6 +2025,27 @@ func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error {
return nil
}
+func (x *Vcpuinfo) toC() (xc C.libxl_vcpuinfo, err error) {
+ C.libxl_vcpuinfo_init(&xc)
+ xc.vcpuid = C.uint32_t(x.Vcpuid)
+ xc.cpu = C.uint32_t(x.Cpu)
+ xc.online = C.bool(x.Online)
+ xc.blocked = C.bool(x.Blocked)
+ xc.running = C.bool(x.Running)
+ xc.vcpu_time = C.uint64_t(x.VcpuTime)
+ xc.cpumap, err = x.Cpumap.toC()
+ if err != nil {
+ C.libxl_vcpuinfo_dispose(&xc)
+ return xc, err
+ }
+ xc.cpumap_soft, err = x.CpumapSoft.toC()
+ if err != nil {
+ C.libxl_vcpuinfo_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *Physinfo) fromC(xc *C.libxl_physinfo) error {
x.ThreadsPerCore = uint32(xc.threads_per_core)
x.CoresPerSocket = uint32(xc.cores_per_socket)
@@ -1259,6 +2073,35 @@ func (x *Physinfo) fromC(xc *C.libxl_physinfo) error {
return nil
}
+func (x *Physinfo) toC() (xc C.libxl_physinfo, err error) {
+ C.libxl_physinfo_init(&xc)
+ xc.threads_per_core = C.uint32_t(x.ThreadsPerCore)
+ xc.cores_per_socket = C.uint32_t(x.CoresPerSocket)
+ xc.max_cpu_id = C.uint32_t(x.MaxCpuId)
+ xc.nr_cpus = C.uint32_t(x.NrCpus)
+ xc.cpu_khz = C.uint32_t(x.CpuKhz)
+ xc.total_pages = C.uint64_t(x.TotalPages)
+ xc.free_pages = C.uint64_t(x.FreePages)
+ xc.scrub_pages = C.uint64_t(x.ScrubPages)
+ xc.outstanding_pages = C.uint64_t(x.OutstandingPages)
+ xc.sharing_freed_pages = C.uint64_t(x.SharingFreedPages)
+ xc.sharing_used_frames = C.uint64_t(x.SharingUsedFrames)
+ xc.max_possible_mfn = C.uint64_t(x.MaxPossibleMfn)
+ xc.nr_nodes = C.uint32_t(x.NrNodes)
+ xc.hw_cap, err = x.HwCap.toC()
+ if err != nil {
+ C.libxl_physinfo_dispose(&xc)
+ return xc, err
+ }
+ xc.cap_hvm = C.bool(x.CapHvm)
+ xc.cap_pv = C.bool(x.CapPv)
+ xc.cap_hvm_directio = C.bool(x.CapHvmDirectio)
+ xc.cap_hap = C.bool(x.CapHap)
+ xc.cap_shadow = C.bool(x.CapShadow)
+ xc.cap_iommu_hap_pt_share = C.bool(x.CapIommuHapPtShare)
+ return xc, nil
+}
+
func (x *Connectorinfo) fromC(xc *C.libxl_connectorinfo) error {
x.UniqueId = C.GoString(xc.unique_id)
x.Width = uint32(xc.width)
@@ -1271,6 +2114,18 @@ func (x *Connectorinfo) fromC(xc *C.libxl_connectorinfo) error {
return nil
}
+func (x *Connectorinfo) toC() (xc C.libxl_connectorinfo, err error) {
+ C.libxl_connectorinfo_init(&xc)
+ xc.unique_id = C.CString(x.UniqueId)
+ xc.width = C.uint32_t(x.Width)
+ xc.height = C.uint32_t(x.Height)
+ xc.req_evtch = C.int(x.ReqEvtch)
+ xc.req_rref = C.int(x.ReqRref)
+ xc.evt_evtch = C.int(x.EvtEvtch)
+ xc.evt_rref = C.int(x.EvtRref)
+ return xc, nil
+}
+
func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1293,6 +2148,18 @@ func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error {
return nil
}
+func (x *Vdisplinfo) toC() (xc C.libxl_vdisplinfo, err error) {
+ C.libxl_vdisplinfo_init(&xc)
+ xc.backend = C.CString(x.Backend)
+ xc.backend_id = C.uint32_t(x.BackendId)
+ xc.frontend = C.CString(x.Frontend)
+ xc.frontend_id = C.uint32_t(x.FrontendId)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.state = C.int(x.State)
+ xc.be_alloc = C.bool(x.BeAlloc)
+ return xc, nil
+}
+
func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error {
x.ReqEvtch = int(xc.req_evtch)
x.ReqRref = int(xc.req_rref)
@@ -1300,6 +2167,13 @@ func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error {
return nil
}
+func (x *Streaminfo) toC() (xc C.libxl_streaminfo, err error) {
+ C.libxl_streaminfo_init(&xc)
+ xc.req_evtch = C.int(x.ReqEvtch)
+ xc.req_rref = C.int(x.ReqRref)
+ return xc, nil
+}
+
func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error {
numVsndStreams := int(xc.num_vsnd_streams)
cStreams := (*[1 << 28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams]
@@ -1315,6 +2189,11 @@ func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error {
return nil
}
+func (x *Pcminfo) toC() (xc C.libxl_pcminfo, err error) {
+ C.libxl_pcminfo_init(&xc)
+ return xc, nil
+}
+
func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1336,6 +2215,17 @@ func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error {
return nil
}
+func (x *Vsndinfo) toC() (xc C.libxl_vsndinfo, err error) {
+ C.libxl_vsndinfo_init(&xc)
+ xc.backend = C.CString(x.Backend)
+ xc.backend_id = C.uint32_t(x.BackendId)
+ xc.frontend = C.CString(x.Frontend)
+ xc.frontend_id = C.uint32_t(x.FrontendId)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.state = C.int(x.State)
+ return xc, nil
+}
+
func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1349,6 +2239,19 @@ func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error {
return nil
}
+func (x *Vkbinfo) toC() (xc C.libxl_vkbinfo, err error) {
+ C.libxl_vkbinfo_init(&xc)
+ xc.backend = C.CString(x.Backend)
+ xc.backend_id = C.uint32_t(x.BackendId)
+ xc.frontend = C.CString(x.Frontend)
+ xc.frontend_id = C.uint32_t(x.FrontendId)
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.state = C.int(x.State)
+ xc.evtch = C.int(x.Evtch)
+ xc.rref = C.int(x.Rref)
+ return xc, nil
+}
+
func (x *Numainfo) fromC(xc *C.libxl_numainfo) error {
x.Size = uint64(xc.size)
x.Free = uint64(xc.free)
@@ -1362,6 +2265,13 @@ func (x *Numainfo) fromC(xc *C.libxl_numainfo) error {
return nil
}
+func (x *Numainfo) toC() (xc C.libxl_numainfo, err error) {
+ C.libxl_numainfo_init(&xc)
+ xc.size = C.uint64_t(x.Size)
+ xc.free = C.uint64_t(x.Free)
+ return xc, nil
+}
+
func (x *Cputopology) fromC(xc *C.libxl_cputopology) error {
x.Core = uint32(xc.core)
x.Socket = uint32(xc.socket)
@@ -1370,6 +2280,14 @@ func (x *Cputopology) fromC(xc *C.libxl_cputopology) error {
return nil
}
+func (x *Cputopology) toC() (xc C.libxl_cputopology, err error) {
+ C.libxl_cputopology_init(&xc)
+ xc.core = C.uint32_t(x.Core)
+ xc.socket = C.uint32_t(x.Socket)
+ xc.node = C.uint32_t(x.Node)
+ return xc, nil
+}
+
func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error {
x.Seg = uint16(xc.seg)
x.Bus = byte(xc.bus)
@@ -1379,6 +2297,15 @@ func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error {
return nil
}
+func (x *Pcitopology) toC() (xc C.libxl_pcitopology, err error) {
+ C.libxl_pcitopology_init(&xc)
+ xc.seg = C.uint16_t(x.Seg)
+ xc.bus = C.uint8_t(x.Bus)
+ xc.devfn = C.uint8_t(x.Devfn)
+ xc.node = C.uint32_t(x.Node)
+ return xc, nil
+}
+
func (x *SchedCreditParams) fromC(xc *C.libxl_sched_credit_params) error {
x.TsliceMs = int(xc.tslice_ms)
x.RatelimitUs = int(xc.ratelimit_us)
@@ -1387,12 +2314,26 @@ func (x *SchedCreditParams) fromC(xc *C.libxl_sched_credit_params) error {
return nil
}
+func (x *SchedCreditParams) toC() (xc C.libxl_sched_credit_params, err error) {
+ C.libxl_sched_credit_params_init(&xc)
+ xc.tslice_ms = C.int(x.TsliceMs)
+ xc.ratelimit_us = C.int(x.RatelimitUs)
+ xc.vcpu_migr_delay_us = C.int(x.VcpuMigrDelayUs)
+ return xc, nil
+}
+
func (x *SchedCredit2Params) fromC(xc *C.libxl_sched_credit2_params) error {
x.RatelimitUs = int(xc.ratelimit_us)
return nil
}
+func (x *SchedCredit2Params) toC() (xc C.libxl_sched_credit2_params, err error) {
+ C.libxl_sched_credit2_params_init(&xc)
+ xc.ratelimit_us = C.int(x.RatelimitUs)
+ return xc, nil
+}
+
func (x *DomainRemusInfo) fromC(xc *C.libxl_domain_remus_info) error {
x.Interval = int(xc.interval)
if err := x.AllowUnsafe.fromC(&xc.allow_unsafe); err != nil {
@@ -1421,6 +2362,48 @@ func (x *DomainRemusInfo) fromC(xc *C.libxl_domain_remus_info) error {
return nil
}
+func (x *DomainRemusInfo) toC() (xc C.libxl_domain_remus_info, err error) {
+ C.libxl_domain_remus_info_init(&xc)
+ xc.interval = C.int(x.Interval)
+ xc.allow_unsafe, err = x.AllowUnsafe.toC()
+ if err != nil {
+ C.libxl_domain_remus_info_dispose(&xc)
+ return xc, err
+ }
+ xc.blackhole, err = x.Blackhole.toC()
+ if err != nil {
+ C.libxl_domain_remus_info_dispose(&xc)
+ return xc, err
+ }
+ xc.compression, err = x.Compression.toC()
+ if err != nil {
+ C.libxl_domain_remus_info_dispose(&xc)
+ return xc, err
+ }
+ xc.netbuf, err = x.Netbuf.toC()
+ if err != nil {
+ C.libxl_domain_remus_info_dispose(&xc)
+ return xc, err
+ }
+ xc.netbufscript = C.CString(x.Netbufscript)
+ xc.diskbuf, err = x.Diskbuf.toC()
+ if err != nil {
+ C.libxl_domain_remus_info_dispose(&xc)
+ return xc, err
+ }
+ xc.colo, err = x.Colo.toC()
+ if err != nil {
+ C.libxl_domain_remus_info_dispose(&xc)
+ return xc, err
+ }
+ xc.userspace_colo_proxy, err = x.UserspaceColoProxy.toC()
+ if err != nil {
+ C.libxl_domain_remus_info_dispose(&xc)
+ return xc, err
+ }
+ return xc, nil
+}
+
func (x *Event) fromC(xc *C.libxl_event) error {
if err := x.Link.fromC(&xc.link); err != nil {
return err
@@ -1490,6 +2473,23 @@ func (x *EventTypeUnionOperationComplete) fromC(xc *C.libxl_event) error {
return nil
}
+func (x *Event) toC() (xc C.libxl_event, err error) {
+ C.libxl_event_init(&xc)
+ xc.link, err = x.Link.toC()
+ if err != nil {
+ C.libxl_event_dispose(&xc)
+ return xc, err
+ }
+ xc.domid = C.libxl_domid(x.Domid)
+ xc.domuuid, err = x.Domuuid.toC()
+ if err != nil {
+ C.libxl_event_dispose(&xc)
+ return xc, err
+ }
+ xc.for_user = C.uint64_t(x.ForUser)
+ return xc, nil
+}
+
func (x *PsrCatInfo) fromC(xc *C.libxl_psr_cat_info) error {
x.Id = uint32(xc.id)
x.CosMax = uint32(xc.cos_max)
@@ -1499,6 +2499,15 @@ func (x *PsrCatInfo) fromC(xc *C.libxl_psr_cat_info) error {
return nil
}
+func (x *PsrCatInfo) toC() (xc C.libxl_psr_cat_info, err error) {
+ C.libxl_psr_cat_info_init(&xc)
+ xc.id = C.uint32_t(x.Id)
+ xc.cos_max = C.uint32_t(x.CosMax)
+ xc.cbm_len = C.uint32_t(x.CbmLen)
+ xc.cdp_enabled = C.bool(x.CdpEnabled)
+ return xc, nil
+}
+
func (x *PsrHwInfo) fromC(xc *C.libxl_psr_hw_info) error {
x.Id = uint32(xc.id)
x.Type = PsrFeatType(xc._type)
@@ -1545,3 +2554,9 @@ func (x *PsrHwInfoTypeUnionMba) fromC(xc *C.libxl_psr_hw_info) error {
x.Linear = bool(tmp.linear)
return nil
}
+
+func (x *PsrHwInfo) toC() (xc C.libxl_psr_hw_info, err error) {
+ C.libxl_psr_hw_info_init(&xc)
+ xc.id = C.uint32_t(x.Id)
+ return xc, nil
+}
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 19/22] golang/xenlight: implement keyed union Go to C marshaling
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (17 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 18/22] golang/xenlight: begin Go to C type marshaling Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 20/22] golang/xenlight: implement array " Nick Rosbrook
` (2 subsequent siblings)
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Since the C union cannot be directly populated, populate the fields of the
corresponding C struct defined in the cgo preamble, and then copy that
struct as bytes into the byte slice that Go uses as the union.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
tools/golang/xenlight/gengotypes.py | 77 ++++++-
tools/golang/xenlight/helpers.gen.go | 325 +++++++++++++++++++++++++++
2 files changed, 400 insertions(+), 2 deletions(-)
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
index cb9b18218f..1839ac14b6 100644
--- a/tools/golang/xenlight/gengotypes.py
+++ b/tools/golang/xenlight/gengotypes.py
@@ -504,8 +504,7 @@ def xenlight_golang_define_to_C(ty = None, typename = None, nested = False):
s += xenlight_golang_define_to_C(f.type, typename=f.name, nested=True)
elif isinstance(f.type, idl.KeyedUnion):
- # TODO
- pass
+ s += xenlight_golang_union_to_C(f.type, f.name, ty.typename, ty.dispose_fn)
else:
raise Exception('type {} not supported'.format(f.type))
@@ -516,6 +515,80 @@ def xenlight_golang_define_to_C(ty = None, typename = None, nested = False):
return s
+def xenlight_golang_union_to_C(ty = None, union_name = '',
+ struct_name = '', dispose_fn = ''):
+ keyname = ty.keyvar.name
+ gokeyname = xenlight_golang_fmt_name(keyname)
+ keytype = ty.keyvar.type.typename
+ gokeytype = xenlight_golang_fmt_name(keytype)
+
+ interface_name = '{}_{}_union'.format(struct_name, keyname)
+ interface_name = xenlight_golang_fmt_name(interface_name, exported=False)
+
+ cgo_keyname = keyname
+ if cgo_keyname in go_keywords:
+ cgo_keyname = '_' + cgo_keyname
+
+
+ s = 'xc.{} = C.{}(x.{})\n'.format(cgo_keyname,keytype,gokeyname)
+ s += 'switch x.{}{{\n'.format(gokeyname)
+
+ # Create switch statement to determine how to populate the C union.
+ for f in ty.fields:
+ key_val = '{}_{}'.format(keytype, f.name)
+ key_val = xenlight_golang_fmt_name(key_val)
+ if f.type is None:
+ continue
+
+ s += 'case {}:\n'.format(key_val)
+ cgotype = '{}_{}_union_{}'.format(struct_name,keyname,f.name)
+ gotype = xenlight_golang_fmt_name(cgotype)
+ goname = '{}_{}'.format(keyname,f.name)
+ goname = xenlight_golang_fmt_name(goname,exported=False)
+
+ field_name = xenlight_golang_fmt_name('{}_union'.format(keyname))
+ s += 'tmp, ok := x.{}.({})\n'.format(field_name,gotype)
+ s += 'if !ok {\n'
+ s += 'C.{}(&xc)\n'.format(dispose_fn)
+ s += 'return xc,errors.New("wrong type for union key {}")\n'.format(keyname)
+ s += '}\n'
+
+ s += 'var {} C.{}\n'.format(f.name,cgotype)
+ for uf in f.type.fields:
+ gotypename = xenlight_golang_fmt_name(uf.type.typename)
+ ctypename = uf.type.typename
+ gofname = xenlight_golang_fmt_name(uf.name)
+
+ is_castable = (uf.type.json_parse_type == 'JSON_INTEGER' or
+ isinstance(uf.type, idl.Enumeration) or
+ gotypename in go_builtin_types)
+
+ if not is_castable:
+ s += '{}.{}, err = tmp.{}.toC()\n'.format(f.name,uf.name,gofname)
+ s += 'if err != nil {\n'
+ s += 'C.{}(&xc)\n'.format(dispose_fn)
+ s += 'return xc,err \n}\n'
+
+ elif gotypename == 'string':
+ s += '{}.{} = C.CString(tmp.{})\n'.format(f.name,uf.name,gofname)
+
+ else:
+ s += '{}.{} = C.{}(tmp.{})\n'.format(f.name,uf.name,ctypename,gofname)
+
+ # The union is still represented as Go []byte.
+ s += '{}Bytes := C.GoBytes(unsafe.Pointer(&{}),C.sizeof_{})\n'.format(f.name,
+ f.name,
+ cgotype)
+ s += 'copy(xc.{}[:],{}Bytes)\n'.format(union_name,f.name)
+
+ # End switch statement
+ s += 'default:\n'
+ err_string = '"invalid union key \'%v\'", x.{}'.format(gokeyname)
+ s += 'return xc, fmt.Errorf({})'.format(err_string)
+ s += '}\n'
+
+ return s
+
def xenlight_golang_fmt_name(name, exported = True):
"""
Take a given type name and return an
diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go
index a155b091a7..73ad5e9761 100644
--- a/tools/golang/xenlight/helpers.gen.go
+++ b/tools/golang/xenlight/helpers.gen.go
@@ -326,6 +326,21 @@ func (x *Channelinfo) toC() (xc C.libxl_channelinfo, err error) {
xc.state = C.int(x.State)
xc.evtch = C.int(x.Evtch)
xc.rref = C.int(x.Rref)
+ xc.connection = C.libxl_channel_connection(x.Connection)
+ switch x.Connection {
+ case ChannelConnectionPty:
+ tmp, ok := x.ConnectionUnion.(ChannelinfoConnectionUnionPty)
+ if !ok {
+ C.libxl_channelinfo_dispose(&xc)
+ return xc, errors.New("wrong type for union key connection")
+ }
+ var pty C.libxl_channelinfo_connection_union_pty
+ pty.path = C.CString(tmp.Path)
+ ptyBytes := C.GoBytes(unsafe.Pointer(&pty), C.sizeof_libxl_channelinfo_connection_union_pty)
+ copy(xc.u[:], ptyBytes)
+ default:
+ return xc, fmt.Errorf("invalid union key '%v'", x.Connection)
+ }
return xc, nil
}
@@ -1031,6 +1046,216 @@ func (x *DomainBuildInfo) toC() (xc C.libxl_domain_build_info, err error) {
return xc, err
}
xc.tee = C.libxl_tee_type(x.Tee)
+ xc._type = C.libxl_domain_type(x.Type)
+ switch x.Type {
+ case DomainTypeHvm:
+ tmp, ok := x.TypeUnion.(DomainBuildInfoTypeUnionHvm)
+ if !ok {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, errors.New("wrong type for union key type")
+ }
+ var hvm C.libxl_domain_build_info_type_union_hvm
+ hvm.firmware = C.CString(tmp.Firmware)
+ hvm.bios = C.libxl_bios_type(tmp.Bios)
+ hvm.pae, err = tmp.Pae.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.apic, err = tmp.Apic.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.acpi, err = tmp.Acpi.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.acpi_s3, err = tmp.AcpiS3.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.acpi_s4, err = tmp.AcpiS4.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.acpi_laptop_slate, err = tmp.AcpiLaptopSlate.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.nx, err = tmp.Nx.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.viridian, err = tmp.Viridian.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.viridian_enable, err = tmp.ViridianEnable.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.viridian_disable, err = tmp.ViridianDisable.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.timeoffset = C.CString(tmp.Timeoffset)
+ hvm.hpet, err = tmp.Hpet.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.vpt_align, err = tmp.VptAlign.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.mmio_hole_memkb = C.uint64_t(tmp.MmioHoleMemkb)
+ hvm.timer_mode = C.libxl_timer_mode(tmp.TimerMode)
+ hvm.nested_hvm, err = tmp.NestedHvm.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.altp2m, err = tmp.Altp2M.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.system_firmware = C.CString(tmp.SystemFirmware)
+ hvm.smbios_firmware = C.CString(tmp.SmbiosFirmware)
+ hvm.acpi_firmware = C.CString(tmp.AcpiFirmware)
+ hvm.hdtype = C.libxl_hdtype(tmp.Hdtype)
+ hvm.nographic, err = tmp.Nographic.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.vga, err = tmp.Vga.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.vnc, err = tmp.Vnc.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.keymap = C.CString(tmp.Keymap)
+ hvm.sdl, err = tmp.Sdl.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.spice, err = tmp.Spice.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.gfx_passthru, err = tmp.GfxPassthru.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.gfx_passthru_kind = C.libxl_gfx_passthru_kind(tmp.GfxPassthruKind)
+ hvm.serial = C.CString(tmp.Serial)
+ hvm.boot = C.CString(tmp.Boot)
+ hvm.usb, err = tmp.Usb.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.usbversion = C.int(tmp.Usbversion)
+ hvm.usbdevice = C.CString(tmp.Usbdevice)
+ hvm.vkb_device, err = tmp.VkbDevice.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.soundhw = C.CString(tmp.Soundhw)
+ hvm.xen_platform_pci, err = tmp.XenPlatformPci.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.usbdevice_list, err = tmp.UsbdeviceList.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.vendor_device = C.libxl_vendor_device(tmp.VendorDevice)
+ hvm.ms_vm_genid, err = tmp.MsVmGenid.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.serial_list, err = tmp.SerialList.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.rdm, err = tmp.Rdm.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ hvm.rdm_mem_boundary_memkb = C.uint64_t(tmp.RdmMemBoundaryMemkb)
+ hvm.mca_caps = C.uint64_t(tmp.McaCaps)
+ hvmBytes := C.GoBytes(unsafe.Pointer(&hvm), C.sizeof_libxl_domain_build_info_type_union_hvm)
+ copy(xc.u[:], hvmBytes)
+ case DomainTypePv:
+ tmp, ok := x.TypeUnion.(DomainBuildInfoTypeUnionPv)
+ if !ok {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, errors.New("wrong type for union key type")
+ }
+ var pv C.libxl_domain_build_info_type_union_pv
+ pv.kernel = C.CString(tmp.Kernel)
+ pv.slack_memkb = C.uint64_t(tmp.SlackMemkb)
+ pv.bootloader = C.CString(tmp.Bootloader)
+ pv.bootloader_args, err = tmp.BootloaderArgs.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ pv.cmdline = C.CString(tmp.Cmdline)
+ pv.ramdisk = C.CString(tmp.Ramdisk)
+ pv.features = C.CString(tmp.Features)
+ pv.e820_host, err = tmp.E820Host.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ pvBytes := C.GoBytes(unsafe.Pointer(&pv), C.sizeof_libxl_domain_build_info_type_union_pv)
+ copy(xc.u[:], pvBytes)
+ case DomainTypePvh:
+ tmp, ok := x.TypeUnion.(DomainBuildInfoTypeUnionPvh)
+ if !ok {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, errors.New("wrong type for union key type")
+ }
+ var pvh C.libxl_domain_build_info_type_union_pvh
+ pvh.pvshim, err = tmp.Pvshim.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ pvh.pvshim_path = C.CString(tmp.PvshimPath)
+ pvh.pvshim_cmdline = C.CString(tmp.PvshimCmdline)
+ pvh.pvshim_extra = C.CString(tmp.PvshimExtra)
+ pvhBytes := C.GoBytes(unsafe.Pointer(&pvh), C.sizeof_libxl_domain_build_info_type_union_pvh)
+ copy(xc.u[:], pvhBytes)
+ default:
+ return xc, fmt.Errorf("invalid union key '%v'", x.Type)
+ }
xc.arch_arm.gic_version = C.libxl_gic_version(x.ArchArm.GicVersion)
xc.arch_arm.vuart = C.libxl_vuart_type(x.ArchArm.Vuart)
xc.altp2m = C.libxl_altp2m_mode(x.Altp2M)
@@ -1422,6 +1647,22 @@ func (x *DeviceUsbdev) toC() (xc C.libxl_device_usbdev, err error) {
C.libxl_device_usbdev_init(&xc)
xc.ctrl = C.libxl_devid(x.Ctrl)
xc.port = C.int(x.Port)
+ xc._type = C.libxl_usbdev_type(x.Type)
+ switch x.Type {
+ case UsbdevTypeHostdev:
+ tmp, ok := x.TypeUnion.(DeviceUsbdevTypeUnionHostdev)
+ if !ok {
+ C.libxl_device_usbdev_dispose(&xc)
+ return xc, errors.New("wrong type for union key type")
+ }
+ var hostdev C.libxl_device_usbdev_type_union_hostdev
+ hostdev.hostbus = C.uint8_t(tmp.Hostbus)
+ hostdev.hostaddr = C.uint8_t(tmp.Hostaddr)
+ hostdevBytes := C.GoBytes(unsafe.Pointer(&hostdev), C.sizeof_libxl_device_usbdev_type_union_hostdev)
+ copy(xc.u[:], hostdevBytes)
+ default:
+ return xc, fmt.Errorf("invalid union key '%v'", x.Type)
+ }
return xc, nil
}
@@ -1535,6 +1776,21 @@ func (x *DeviceChannel) toC() (xc C.libxl_device_channel, err error) {
xc.backend_domname = C.CString(x.BackendDomname)
xc.devid = C.libxl_devid(x.Devid)
xc.name = C.CString(x.Name)
+ xc.connection = C.libxl_channel_connection(x.Connection)
+ switch x.Connection {
+ case ChannelConnectionSocket:
+ tmp, ok := x.ConnectionUnion.(DeviceChannelConnectionUnionSocket)
+ if !ok {
+ C.libxl_device_channel_dispose(&xc)
+ return xc, errors.New("wrong type for union key connection")
+ }
+ var socket C.libxl_device_channel_connection_union_socket
+ socket.path = C.CString(tmp.Path)
+ socketBytes := C.GoBytes(unsafe.Pointer(&socket), C.sizeof_libxl_device_channel_connection_union_socket)
+ copy(xc.u[:], socketBytes)
+ default:
+ return xc, fmt.Errorf("invalid union key '%v'", x.Connection)
+ }
return xc, nil
}
@@ -2487,6 +2743,46 @@ func (x *Event) toC() (xc C.libxl_event, err error) {
return xc, err
}
xc.for_user = C.uint64_t(x.ForUser)
+ xc._type = C.libxl_event_type(x.Type)
+ switch x.Type {
+ case EventTypeDomainShutdown:
+ tmp, ok := x.TypeUnion.(EventTypeUnionDomainShutdown)
+ if !ok {
+ C.libxl_event_dispose(&xc)
+ return xc, errors.New("wrong type for union key type")
+ }
+ var domain_shutdown C.libxl_event_type_union_domain_shutdown
+ domain_shutdown.shutdown_reason = C.uint8_t(tmp.ShutdownReason)
+ domain_shutdownBytes := C.GoBytes(unsafe.Pointer(&domain_shutdown), C.sizeof_libxl_event_type_union_domain_shutdown)
+ copy(xc.u[:], domain_shutdownBytes)
+ case EventTypeDiskEject:
+ tmp, ok := x.TypeUnion.(EventTypeUnionDiskEject)
+ if !ok {
+ C.libxl_event_dispose(&xc)
+ return xc, errors.New("wrong type for union key type")
+ }
+ var disk_eject C.libxl_event_type_union_disk_eject
+ disk_eject.vdev = C.CString(tmp.Vdev)
+ disk_eject.disk, err = tmp.Disk.toC()
+ if err != nil {
+ C.libxl_event_dispose(&xc)
+ return xc, err
+ }
+ disk_ejectBytes := C.GoBytes(unsafe.Pointer(&disk_eject), C.sizeof_libxl_event_type_union_disk_eject)
+ copy(xc.u[:], disk_ejectBytes)
+ case EventTypeOperationComplete:
+ tmp, ok := x.TypeUnion.(EventTypeUnionOperationComplete)
+ if !ok {
+ C.libxl_event_dispose(&xc)
+ return xc, errors.New("wrong type for union key type")
+ }
+ var operation_complete C.libxl_event_type_union_operation_complete
+ operation_complete.rc = C.int(tmp.Rc)
+ operation_completeBytes := C.GoBytes(unsafe.Pointer(&operation_complete), C.sizeof_libxl_event_type_union_operation_complete)
+ copy(xc.u[:], operation_completeBytes)
+ default:
+ return xc, fmt.Errorf("invalid union key '%v'", x.Type)
+ }
return xc, nil
}
@@ -2558,5 +2854,34 @@ func (x *PsrHwInfoTypeUnionMba) fromC(xc *C.libxl_psr_hw_info) error {
func (x *PsrHwInfo) toC() (xc C.libxl_psr_hw_info, err error) {
C.libxl_psr_hw_info_init(&xc)
xc.id = C.uint32_t(x.Id)
+ xc._type = C.libxl_psr_feat_type(x.Type)
+ switch x.Type {
+ case PsrFeatTypeCat:
+ tmp, ok := x.TypeUnion.(PsrHwInfoTypeUnionCat)
+ if !ok {
+ C.libxl_psr_hw_info_dispose(&xc)
+ return xc, errors.New("wrong type for union key type")
+ }
+ var cat C.libxl_psr_hw_info_type_union_cat
+ cat.cos_max = C.uint32_t(tmp.CosMax)
+ cat.cbm_len = C.uint32_t(tmp.CbmLen)
+ cat.cdp_enabled = C.bool(tmp.CdpEnabled)
+ catBytes := C.GoBytes(unsafe.Pointer(&cat), C.sizeof_libxl_psr_hw_info_type_union_cat)
+ copy(xc.u[:], catBytes)
+ case PsrFeatTypeMba:
+ tmp, ok := x.TypeUnion.(PsrHwInfoTypeUnionMba)
+ if !ok {
+ C.libxl_psr_hw_info_dispose(&xc)
+ return xc, errors.New("wrong type for union key type")
+ }
+ var mba C.libxl_psr_hw_info_type_union_mba
+ mba.cos_max = C.uint32_t(tmp.CosMax)
+ mba.thrtl_max = C.uint32_t(tmp.ThrtlMax)
+ mba.linear = C.bool(tmp.Linear)
+ mbaBytes := C.GoBytes(unsafe.Pointer(&mba), C.sizeof_libxl_psr_hw_info_type_union_mba)
+ copy(xc.u[:], mbaBytes)
+ default:
+ return xc, fmt.Errorf("invalid union key '%v'", x.Type)
+ }
return xc, nil
}
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 20/22] golang/xenlight: implement array Go to C marshaling
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (18 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 19/22] golang/xenlight: implement keyed union Go to C marshaling Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 21/22] golang/xenlight: revise use of Context type Nick Rosbrook
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 22/22] golang/xenlight: add error return type to Context.Cpupoolinfo Nick Rosbrook
21 siblings, 0 replies; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
tools/golang/xenlight/gengotypes.py | 44 +++-
tools/golang/xenlight/helpers.gen.go | 359 +++++++++++++++++++++++++++
2 files changed, 402 insertions(+), 1 deletion(-)
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
index 1839ac14b6..24d27e30ad 100644
--- a/tools/golang/xenlight/gengotypes.py
+++ b/tools/golang/xenlight/gengotypes.py
@@ -458,7 +458,7 @@ def xenlight_golang_define_to_C(ty = None, typename = None, nested = False):
for f in ty.fields:
if f.type.typename is not None:
if isinstance(f.type, idl.Array):
- # TODO
+ s += xenlight_golang_array_to_C(f, ty.dispose_fn)
continue
gotypename = xenlight_golang_fmt_name(f.type.typename)
@@ -589,6 +589,48 @@ def xenlight_golang_union_to_C(ty = None, union_name = '',
return s
+def xenlight_golang_array_to_C(ty = None, dispose_fn = ''):
+ s = ''
+
+ gotypename = xenlight_golang_fmt_name(ty.type.elem_type.typename)
+ goname = xenlight_golang_fmt_name(ty.name)
+ ctypename = ty.type.elem_type.typename
+ cname = ty.name
+ clenvar = ty.type.lenvar.name
+ golenvar = xenlight_golang_fmt_name(clenvar,exported=False)
+
+ is_enum = isinstance(ty.type.elem_type,idl.Enumeration)
+ if gotypename in go_builtin_types or is_enum:
+ s += '{} := len(x.{})\n'.format(golenvar,goname)
+ s += 'xc.{} = (*C.{})(C.malloc(C.size_t({}*{})))\n'.format(cname,ctypename,
+ golenvar,golenvar)
+ s += 'xc.{} = C.int({})\n'.format(clenvar,golenvar)
+ s += 'c{} := (*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.format(goname,
+ ctypename,cname,
+ golenvar,golenvar)
+ s += 'for i,v := range x.{} {{\n'.format(goname)
+ s += 'c{}[i] = C.{}(v)\n'.format(goname,ctypename)
+ s += '}\n'
+
+ return s
+
+ s += '{} := len(x.{})\n'.format(golenvar,goname)
+ s += 'xc.{} = (*C.{})(C.malloc(C.ulong({})*C.sizeof_{}))\n'.format(cname,ctypename,
+ golenvar,ctypename)
+ s += 'xc.{} = C.int({})\n'.format(clenvar,golenvar)
+ s += 'c{} := (*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.format(goname,
+ ctypename,cname,
+ golenvar,golenvar)
+ s += 'for i,v := range x.{} {{\n'.format(goname)
+ s += 'tmp, err := v.toC()\n'
+ s += 'if err != nil {\n'
+ s += 'C.{}(&xc)\n'.format(dispose_fn)
+ s += 'return xc,err\n}\n'
+ s += 'c{}[i] = tmp\n'.format(goname)
+ s += '}\n'
+
+ return s
+
def xenlight_golang_fmt_name(name, exported = True):
"""
Take a given type name and return an
diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go
index 73ad5e9761..98b4bba4b2 100644
--- a/tools/golang/xenlight/helpers.gen.go
+++ b/tools/golang/xenlight/helpers.gen.go
@@ -545,6 +545,18 @@ func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
func (x *VcpuSchedParams) toC() (xc C.libxl_vcpu_sched_params, err error) {
C.libxl_vcpu_sched_params_init(&xc)
xc.sched = C.libxl_scheduler(x.Sched)
+ numVcpus := len(x.Vcpus)
+ xc.vcpus = (*C.libxl_sched_params)(C.malloc(C.ulong(numVcpus) * C.sizeof_libxl_sched_params))
+ xc.num_vcpus = C.int(numVcpus)
+ cVcpus := (*[1 << 28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:numVcpus:numVcpus]
+ for i, v := range x.Vcpus {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_vcpu_sched_params_dispose(&xc)
+ return xc, err
+ }
+ cVcpus[i] = tmp
+ }
return xc, nil
}
@@ -593,6 +605,13 @@ func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error {
func (x *VnodeInfo) toC() (xc C.libxl_vnode_info, err error) {
C.libxl_vnode_info_init(&xc)
xc.memkb = C.uint64_t(x.Memkb)
+ numDistances := len(x.Distances)
+ xc.distances = (*C.uint32_t)(C.malloc(C.size_t(numDistances * numDistances)))
+ xc.num_distances = C.int(numDistances)
+ cDistances := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.distances))[:numDistances:numDistances]
+ for i, v := range x.Distances {
+ cDistances[i] = C.uint32_t(v)
+ }
xc.pnode = C.uint32_t(x.Pnode)
xc.vcpus, err = x.Vcpus.toC()
if err != nil {
@@ -946,6 +965,30 @@ func (x *DomainBuildInfo) toC() (xc C.libxl_domain_build_info, err error) {
C.libxl_domain_build_info_dispose(&xc)
return xc, err
}
+ numVcpuHardAffinity := len(x.VcpuHardAffinity)
+ xc.vcpu_hard_affinity = (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuHardAffinity) * C.sizeof_libxl_bitmap))
+ xc.num_vcpu_hard_affinity = C.int(numVcpuHardAffinity)
+ cVcpuHardAffinity := (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_hard_affinity))[:numVcpuHardAffinity:numVcpuHardAffinity]
+ for i, v := range x.VcpuHardAffinity {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ cVcpuHardAffinity[i] = tmp
+ }
+ numVcpuSoftAffinity := len(x.VcpuSoftAffinity)
+ xc.vcpu_soft_affinity = (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuSoftAffinity) * C.sizeof_libxl_bitmap))
+ xc.num_vcpu_soft_affinity = C.int(numVcpuSoftAffinity)
+ cVcpuSoftAffinity := (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_soft_affinity))[:numVcpuSoftAffinity:numVcpuSoftAffinity]
+ for i, v := range x.VcpuSoftAffinity {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ cVcpuSoftAffinity[i] = tmp
+ }
xc.numa_placement, err = x.NumaPlacement.toC()
if err != nil {
C.libxl_domain_build_info_dispose(&xc)
@@ -976,6 +1019,18 @@ func (x *DomainBuildInfo) toC() (xc C.libxl_domain_build_info, err error) {
return xc, err
}
xc.blkdev_start = C.CString(x.BlkdevStart)
+ numVnumaNodes := len(x.VnumaNodes)
+ xc.vnuma_nodes = (*C.libxl_vnode_info)(C.malloc(C.ulong(numVnumaNodes) * C.sizeof_libxl_vnode_info))
+ xc.num_vnuma_nodes = C.int(numVnumaNodes)
+ cVnumaNodes := (*[1 << 28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_nodes))[:numVnumaNodes:numVnumaNodes]
+ for i, v := range x.VnumaNodes {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ cVnumaNodes[i] = tmp
+ }
xc.max_grant_frames = C.uint32_t(x.MaxGrantFrames)
xc.max_maptrack_frames = C.uint32_t(x.MaxMaptrackFrames)
xc.device_model_version = C.libxl_device_model_version(x.DeviceModelVersion)
@@ -1008,6 +1063,37 @@ func (x *DomainBuildInfo) toC() (xc C.libxl_domain_build_info, err error) {
C.libxl_domain_build_info_dispose(&xc)
return xc, err
}
+ numIoports := len(x.Ioports)
+ xc.ioports = (*C.libxl_ioport_range)(C.malloc(C.ulong(numIoports) * C.sizeof_libxl_ioport_range))
+ xc.num_ioports = C.int(numIoports)
+ cIoports := (*[1 << 28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports))[:numIoports:numIoports]
+ for i, v := range x.Ioports {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ cIoports[i] = tmp
+ }
+ numIrqs := len(x.Irqs)
+ xc.irqs = (*C.uint32_t)(C.malloc(C.size_t(numIrqs * numIrqs)))
+ xc.num_irqs = C.int(numIrqs)
+ cIrqs := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:numIrqs:numIrqs]
+ for i, v := range x.Irqs {
+ cIrqs[i] = C.uint32_t(v)
+ }
+ numIomem := len(x.Iomem)
+ xc.iomem = (*C.libxl_iomem_range)(C.malloc(C.ulong(numIomem) * C.sizeof_libxl_iomem_range))
+ xc.num_iomem = C.int(numIomem)
+ cIomem := (*[1 << 28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:numIomem:numIomem]
+ for i, v := range x.Iomem {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_build_info_dispose(&xc)
+ return xc, err
+ }
+ cIomem[i] = tmp
+ }
xc.claim_mode, err = x.ClaimMode.toC()
if err != nil {
C.libxl_domain_build_info_dispose(&xc)
@@ -1835,6 +1921,18 @@ func (x *DeviceVdispl) toC() (xc C.libxl_device_vdispl, err error) {
xc.backend_domname = C.CString(x.BackendDomname)
xc.devid = C.libxl_devid(x.Devid)
xc.be_alloc = C.bool(x.BeAlloc)
+ numConnectors := len(x.Connectors)
+ xc.connectors = (*C.libxl_connector_param)(C.malloc(C.ulong(numConnectors) * C.sizeof_libxl_connector_param))
+ xc.num_connectors = C.int(numConnectors)
+ cConnectors := (*[1 << 28]C.libxl_connector_param)(unsafe.Pointer(xc.connectors))[:numConnectors:numConnectors]
+ for i, v := range x.Connectors {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_device_vdispl_dispose(&xc)
+ return xc, err
+ }
+ cConnectors[i] = tmp
+ }
return xc, nil
}
@@ -1860,6 +1958,20 @@ func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error {
func (x *VsndParams) toC() (xc C.libxl_vsnd_params, err error) {
C.libxl_vsnd_params_init(&xc)
+ numSampleRates := len(x.SampleRates)
+ xc.sample_rates = (*C.uint32_t)(C.malloc(C.size_t(numSampleRates * numSampleRates)))
+ xc.num_sample_rates = C.int(numSampleRates)
+ cSampleRates := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.sample_rates))[:numSampleRates:numSampleRates]
+ for i, v := range x.SampleRates {
+ cSampleRates[i] = C.uint32_t(v)
+ }
+ numSampleFormats := len(x.SampleFormats)
+ xc.sample_formats = (*C.libxl_vsnd_pcm_format)(C.malloc(C.size_t(numSampleFormats * numSampleFormats)))
+ xc.num_sample_formats = C.int(numSampleFormats)
+ cSampleFormats := (*[1 << 28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc.sample_formats))[:numSampleFormats:numSampleFormats]
+ for i, v := range x.SampleFormats {
+ cSampleFormats[i] = C.libxl_vsnd_pcm_format(v)
+ }
xc.channels_min = C.uint32_t(x.ChannelsMin)
xc.channels_max = C.uint32_t(x.ChannelsMax)
xc.buffer_size = C.uint32_t(x.BufferSize)
@@ -1915,6 +2027,18 @@ func (x *VsndPcm) toC() (xc C.libxl_vsnd_pcm, err error) {
C.libxl_vsnd_pcm_dispose(&xc)
return xc, err
}
+ numVsndStreams := len(x.Streams)
+ xc.streams = (*C.libxl_vsnd_stream)(C.malloc(C.ulong(numVsndStreams) * C.sizeof_libxl_vsnd_stream))
+ xc.num_vsnd_streams = C.int(numVsndStreams)
+ cStreams := (*[1 << 28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams]
+ for i, v := range x.Streams {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_vsnd_pcm_dispose(&xc)
+ return xc, err
+ }
+ cStreams[i] = tmp
+ }
return xc, nil
}
@@ -1953,6 +2077,18 @@ func (x *DeviceVsnd) toC() (xc C.libxl_device_vsnd, err error) {
C.libxl_device_vsnd_dispose(&xc)
return xc, err
}
+ numVsndPcms := len(x.Pcms)
+ xc.pcms = (*C.libxl_vsnd_pcm)(C.malloc(C.ulong(numVsndPcms) * C.sizeof_libxl_vsnd_pcm))
+ xc.num_vsnd_pcms = C.int(numVsndPcms)
+ cPcms := (*[1 << 28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms]
+ for i, v := range x.Pcms {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_device_vsnd_dispose(&xc)
+ return xc, err
+ }
+ cPcms[i] = tmp
+ }
return xc, nil
}
@@ -2134,6 +2270,186 @@ func (x *DomainConfig) toC() (xc C.libxl_domain_config, err error) {
C.libxl_domain_config_dispose(&xc)
return xc, err
}
+ numDisks := len(x.Disks)
+ xc.disks = (*C.libxl_device_disk)(C.malloc(C.ulong(numDisks) * C.sizeof_libxl_device_disk))
+ xc.num_disks = C.int(numDisks)
+ cDisks := (*[1 << 28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:numDisks:numDisks]
+ for i, v := range x.Disks {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cDisks[i] = tmp
+ }
+ numNics := len(x.Nics)
+ xc.nics = (*C.libxl_device_nic)(C.malloc(C.ulong(numNics) * C.sizeof_libxl_device_nic))
+ xc.num_nics = C.int(numNics)
+ cNics := (*[1 << 28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:numNics:numNics]
+ for i, v := range x.Nics {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cNics[i] = tmp
+ }
+ numPcidevs := len(x.Pcidevs)
+ xc.pcidevs = (*C.libxl_device_pci)(C.malloc(C.ulong(numPcidevs) * C.sizeof_libxl_device_pci))
+ xc.num_pcidevs = C.int(numPcidevs)
+ cPcidevs := (*[1 << 28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))[:numPcidevs:numPcidevs]
+ for i, v := range x.Pcidevs {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cPcidevs[i] = tmp
+ }
+ numRdms := len(x.Rdms)
+ xc.rdms = (*C.libxl_device_rdm)(C.malloc(C.ulong(numRdms) * C.sizeof_libxl_device_rdm))
+ xc.num_rdms = C.int(numRdms)
+ cRdms := (*[1 << 28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:numRdms:numRdms]
+ for i, v := range x.Rdms {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cRdms[i] = tmp
+ }
+ numDtdevs := len(x.Dtdevs)
+ xc.dtdevs = (*C.libxl_device_dtdev)(C.malloc(C.ulong(numDtdevs) * C.sizeof_libxl_device_dtdev))
+ xc.num_dtdevs = C.int(numDtdevs)
+ cDtdevs := (*[1 << 28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))[:numDtdevs:numDtdevs]
+ for i, v := range x.Dtdevs {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cDtdevs[i] = tmp
+ }
+ numVfbs := len(x.Vfbs)
+ xc.vfbs = (*C.libxl_device_vfb)(C.malloc(C.ulong(numVfbs) * C.sizeof_libxl_device_vfb))
+ xc.num_vfbs = C.int(numVfbs)
+ cVfbs := (*[1 << 28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:numVfbs:numVfbs]
+ for i, v := range x.Vfbs {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cVfbs[i] = tmp
+ }
+ numVkbs := len(x.Vkbs)
+ xc.vkbs = (*C.libxl_device_vkb)(C.malloc(C.ulong(numVkbs) * C.sizeof_libxl_device_vkb))
+ xc.num_vkbs = C.int(numVkbs)
+ cVkbs := (*[1 << 28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:numVkbs:numVkbs]
+ for i, v := range x.Vkbs {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cVkbs[i] = tmp
+ }
+ numVtpms := len(x.Vtpms)
+ xc.vtpms = (*C.libxl_device_vtpm)(C.malloc(C.ulong(numVtpms) * C.sizeof_libxl_device_vtpm))
+ xc.num_vtpms = C.int(numVtpms)
+ cVtpms := (*[1 << 28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:numVtpms:numVtpms]
+ for i, v := range x.Vtpms {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cVtpms[i] = tmp
+ }
+ numP9S := len(x.P9S)
+ xc.p9s = (*C.libxl_device_p9)(C.malloc(C.ulong(numP9S) * C.sizeof_libxl_device_p9))
+ xc.num_p9s = C.int(numP9S)
+ cP9S := (*[1 << 28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:numP9S:numP9S]
+ for i, v := range x.P9S {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cP9S[i] = tmp
+ }
+ numPvcallsifs := len(x.Pvcallsifs)
+ xc.pvcallsifs = (*C.libxl_device_pvcallsif)(C.malloc(C.ulong(numPvcallsifs) * C.sizeof_libxl_device_pvcallsif))
+ xc.num_pvcallsifs = C.int(numPvcallsifs)
+ cPvcallsifs := (*[1 << 28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.pvcallsifs))[:numPvcallsifs:numPvcallsifs]
+ for i, v := range x.Pvcallsifs {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cPvcallsifs[i] = tmp
+ }
+ numVdispls := len(x.Vdispls)
+ xc.vdispls = (*C.libxl_device_vdispl)(C.malloc(C.ulong(numVdispls) * C.sizeof_libxl_device_vdispl))
+ xc.num_vdispls = C.int(numVdispls)
+ cVdispls := (*[1 << 28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispls))[:numVdispls:numVdispls]
+ for i, v := range x.Vdispls {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cVdispls[i] = tmp
+ }
+ numVsnds := len(x.Vsnds)
+ xc.vsnds = (*C.libxl_device_vsnd)(C.malloc(C.ulong(numVsnds) * C.sizeof_libxl_device_vsnd))
+ xc.num_vsnds = C.int(numVsnds)
+ cVsnds := (*[1 << 28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:numVsnds:numVsnds]
+ for i, v := range x.Vsnds {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cVsnds[i] = tmp
+ }
+ numChannels := len(x.Channels)
+ xc.channels = (*C.libxl_device_channel)(C.malloc(C.ulong(numChannels) * C.sizeof_libxl_device_channel))
+ xc.num_channels = C.int(numChannels)
+ cChannels := (*[1 << 28]C.libxl_device_channel)(unsafe.Pointer(xc.channels))[:numChannels:numChannels]
+ for i, v := range x.Channels {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cChannels[i] = tmp
+ }
+ numUsbctrls := len(x.Usbctrls)
+ xc.usbctrls = (*C.libxl_device_usbctrl)(C.malloc(C.ulong(numUsbctrls) * C.sizeof_libxl_device_usbctrl))
+ xc.num_usbctrls = C.int(numUsbctrls)
+ cUsbctrls := (*[1 << 28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbctrls))[:numUsbctrls:numUsbctrls]
+ for i, v := range x.Usbctrls {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cUsbctrls[i] = tmp
+ }
+ numUsbdevs := len(x.Usbdevs)
+ xc.usbdevs = (*C.libxl_device_usbdev)(C.malloc(C.ulong(numUsbdevs) * C.sizeof_libxl_device_usbdev))
+ xc.num_usbdevs = C.int(numUsbdevs)
+ cUsbdevs := (*[1 << 28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdevs))[:numUsbdevs:numUsbdevs]
+ for i, v := range x.Usbdevs {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_domain_config_dispose(&xc)
+ return xc, err
+ }
+ cUsbdevs[i] = tmp
+ }
xc.on_poweroff = C.libxl_action_on_shutdown(x.OnPoweroff)
xc.on_reboot = C.libxl_action_on_shutdown(x.OnReboot)
xc.on_watchdog = C.libxl_action_on_shutdown(x.OnWatchdog)
@@ -2413,6 +2729,18 @@ func (x *Vdisplinfo) toC() (xc C.libxl_vdisplinfo, err error) {
xc.devid = C.libxl_devid(x.Devid)
xc.state = C.int(x.State)
xc.be_alloc = C.bool(x.BeAlloc)
+ numConnectors := len(x.Connectors)
+ xc.connectors = (*C.libxl_connectorinfo)(C.malloc(C.ulong(numConnectors) * C.sizeof_libxl_connectorinfo))
+ xc.num_connectors = C.int(numConnectors)
+ cConnectors := (*[1 << 28]C.libxl_connectorinfo)(unsafe.Pointer(xc.connectors))[:numConnectors:numConnectors]
+ for i, v := range x.Connectors {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_vdisplinfo_dispose(&xc)
+ return xc, err
+ }
+ cConnectors[i] = tmp
+ }
return xc, nil
}
@@ -2447,6 +2775,18 @@ func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error {
func (x *Pcminfo) toC() (xc C.libxl_pcminfo, err error) {
C.libxl_pcminfo_init(&xc)
+ numVsndStreams := len(x.Streams)
+ xc.streams = (*C.libxl_streaminfo)(C.malloc(C.ulong(numVsndStreams) * C.sizeof_libxl_streaminfo))
+ xc.num_vsnd_streams = C.int(numVsndStreams)
+ cStreams := (*[1 << 28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams]
+ for i, v := range x.Streams {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_pcminfo_dispose(&xc)
+ return xc, err
+ }
+ cStreams[i] = tmp
+ }
return xc, nil
}
@@ -2479,6 +2819,18 @@ func (x *Vsndinfo) toC() (xc C.libxl_vsndinfo, err error) {
xc.frontend_id = C.uint32_t(x.FrontendId)
xc.devid = C.libxl_devid(x.Devid)
xc.state = C.int(x.State)
+ numVsndPcms := len(x.Pcms)
+ xc.pcms = (*C.libxl_pcminfo)(C.malloc(C.ulong(numVsndPcms) * C.sizeof_libxl_pcminfo))
+ xc.num_vsnd_pcms = C.int(numVsndPcms)
+ cPcms := (*[1 << 28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms]
+ for i, v := range x.Pcms {
+ tmp, err := v.toC()
+ if err != nil {
+ C.libxl_vsndinfo_dispose(&xc)
+ return xc, err
+ }
+ cPcms[i] = tmp
+ }
return xc, nil
}
@@ -2525,6 +2877,13 @@ func (x *Numainfo) toC() (xc C.libxl_numainfo, err error) {
C.libxl_numainfo_init(&xc)
xc.size = C.uint64_t(x.Size)
xc.free = C.uint64_t(x.Free)
+ numDists := len(x.Dists)
+ xc.dists = (*C.uint32_t)(C.malloc(C.size_t(numDists * numDists)))
+ xc.num_dists = C.int(numDists)
+ cDists := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.dists))[:numDists:numDists]
+ for i, v := range x.Dists {
+ cDists[i] = C.uint32_t(v)
+ }
return xc, nil
}
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* [Xen-devel] [PATCH v3 21/22] golang/xenlight: revise use of Context type
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (19 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 20/22] golang/xenlight: implement array " Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-17 17:28 ` George Dunlap
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 22/22] golang/xenlight: add error return type to Context.Cpupoolinfo Nick Rosbrook
21 siblings, 1 reply; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
Remove the exported global context variable, 'Ctx.' Generally, it is
better to not export global variables for use through a Go package.
However, there are some exceptions that can be found in the standard
library.
Add a NewContext function instead, and remove the Open, IsOpen, and
CheckOpen functions as a result.
Also, comment-out an ineffectual assignment to 'err' inside the function
Context.CpupoolInfo so that compilation does not fail.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
tools/golang/xenlight/xenlight.go | 219 +++++-------------------------
1 file changed, 34 insertions(+), 185 deletions(-)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index f32eb11384..1c431fa4e5 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -74,6 +74,39 @@ func (e Error) Error() string {
return fmt.Sprintf("libxl error: %d", -e)
}
+// Context represents a libxl_ctx.
+type Context struct {
+ ctx *C.libxl_ctx
+ logger *C.xentoollog_logger_stdiostream
+}
+
+// NewContext returns a new Context.
+func NewContext() (*Context, error) {
+ var ctx Context
+
+ ctx.logger = C.xtl_createlogger_stdiostream(C.stderr, C.XTL_ERROR, 0)
+
+ ret := C.libxl_ctx_alloc(&ctx.ctx, C.LIBXL_VERSION, 0, (*C.xentoollog_logger)(unsafe.Pointer(ctx.logger)))
+ if ret != 0 {
+ return nil, Error(ret)
+ }
+
+ return &ctx, nil
+}
+
+// Close closes the Context.
+func (ctx *Context) Close() error {
+ ret := C.libxl_ctx_free(ctx.ctx)
+ ctx.ctx = nil
+ C.xtl_logger_destroy((*C.xentoollog_logger)(unsafe.Pointer(ctx.logger)))
+
+ if ret != 0 {
+ return Error(ret)
+ }
+
+ return nil
+}
+
/*
* Types: Builtins
*/
@@ -298,11 +331,6 @@ func (cpl CpuidPolicyList) toC() (C.libxl_cpuid_policy_list, error) {
return ccpl, nil
}
-type Context struct {
- ctx *C.libxl_ctx
- logger *C.xentoollog_logger_stdiostream
-}
-
// Hwcap represents a libxl_hwcap.
type Hwcap [8]uint32
@@ -453,11 +481,6 @@ func SchedulerFromString(name string) (s Scheduler, err error) {
// libxl_cpupoolinfo * libxl_list_cpupool(libxl_ctx*, int *nb_pool_out);
// void libxl_cpupoolinfo_list_free(libxl_cpupoolinfo *list, int nb_pool);
func (Ctx *Context) ListCpupool() (list []Cpupoolinfo) {
- err := Ctx.CheckOpen()
- if err != nil {
- return
- }
-
var nbPool C.int
c_cpupool_list := C.libxl_list_cpupool(Ctx.ctx, &nbPool)
@@ -481,16 +504,11 @@ func (Ctx *Context) ListCpupool() (list []Cpupoolinfo) {
// int libxl_cpupool_info(libxl_ctx *ctx, libxl_cpupoolinfo *info, uint32_t poolid);
func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool Cpupoolinfo) {
- err := Ctx.CheckOpen()
- if err != nil {
- return
- }
-
var c_cpupool C.libxl_cpupoolinfo
ret := C.libxl_cpupool_info(Ctx.ctx, &c_cpupool, C.uint32_t(Poolid))
if ret != 0 {
- err = Error(-ret)
+ //err = Error(-ret)
return
}
defer C.libxl_cpupoolinfo_dispose(&c_cpupool)
@@ -507,11 +525,6 @@ func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool Cpupoolinfo) {
// FIXME: uuid
// FIXME: Setting poolid
func (Ctx *Context) CpupoolCreate(Name string, Scheduler Scheduler, Cpumap Bitmap) (err error, Poolid uint32) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
poolid := C.uint32_t(C.LIBXL_CPUPOOL_POOLID_ANY)
name := C.CString(Name)
defer C.free(unsafe.Pointer(name))
@@ -540,11 +553,6 @@ func (Ctx *Context) CpupoolCreate(Name string, Scheduler Scheduler, Cpumap Bitma
// int libxl_cpupool_destroy(libxl_ctx *ctx, uint32_t poolid);
func (Ctx *Context) CpupoolDestroy(Poolid uint32) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ret := C.libxl_cpupool_destroy(Ctx.ctx, C.uint32_t(Poolid))
if ret != 0 {
err = Error(-ret)
@@ -556,11 +564,6 @@ func (Ctx *Context) CpupoolDestroy(Poolid uint32) (err error) {
// int libxl_cpupool_cpuadd(libxl_ctx *ctx, uint32_t poolid, int cpu);
func (Ctx *Context) CpupoolCpuadd(Poolid uint32, Cpu int) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ret := C.libxl_cpupool_cpuadd(Ctx.ctx, C.uint32_t(Poolid), C.int(Cpu))
if ret != 0 {
err = Error(-ret)
@@ -573,11 +576,6 @@ func (Ctx *Context) CpupoolCpuadd(Poolid uint32, Cpu int) (err error) {
// int libxl_cpupool_cpuadd_cpumap(libxl_ctx *ctx, uint32_t poolid,
// const libxl_bitmap *cpumap);
func (Ctx *Context) CpupoolCpuaddCpumap(Poolid uint32, Cpumap Bitmap) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
cbm, err := Cpumap.toC()
if err != nil {
return
@@ -595,11 +593,6 @@ func (Ctx *Context) CpupoolCpuaddCpumap(Poolid uint32, Cpumap Bitmap) (err error
// int libxl_cpupool_cpuremove(libxl_ctx *ctx, uint32_t poolid, int cpu);
func (Ctx *Context) CpupoolCpuremove(Poolid uint32, Cpu int) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ret := C.libxl_cpupool_cpuremove(Ctx.ctx, C.uint32_t(Poolid), C.int(Cpu))
if ret != 0 {
err = Error(-ret)
@@ -612,11 +605,6 @@ func (Ctx *Context) CpupoolCpuremove(Poolid uint32, Cpu int) (err error) {
// int libxl_cpupool_cpuremove_cpumap(libxl_ctx *ctx, uint32_t poolid,
// const libxl_bitmap *cpumap);
func (Ctx *Context) CpupoolCpuremoveCpumap(Poolid uint32, Cpumap Bitmap) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
cbm, err := Cpumap.toC()
if err != nil {
return
@@ -634,11 +622,6 @@ func (Ctx *Context) CpupoolCpuremoveCpumap(Poolid uint32, Cpumap Bitmap) (err er
// int libxl_cpupool_rename(libxl_ctx *ctx, const char *name, uint32_t poolid);
func (Ctx *Context) CpupoolRename(Name string, Poolid uint32) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
name := C.CString(Name)
defer C.free(unsafe.Pointer(name))
@@ -653,11 +636,6 @@ func (Ctx *Context) CpupoolRename(Name string, Poolid uint32) (err error) {
// int libxl_cpupool_cpuadd_node(libxl_ctx *ctx, uint32_t poolid, int node, int *cpus);
func (Ctx *Context) CpupoolCpuaddNode(Poolid uint32, Node int) (Cpus int, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ccpus := C.int(0)
ret := C.libxl_cpupool_cpuadd_node(Ctx.ctx, C.uint32_t(Poolid), C.int(Node), &ccpus)
@@ -673,11 +651,6 @@ func (Ctx *Context) CpupoolCpuaddNode(Poolid uint32, Node int) (Cpus int, err er
// int libxl_cpupool_cpuremove_node(libxl_ctx *ctx, uint32_t poolid, int node, int *cpus);
func (Ctx *Context) CpupoolCpuremoveNode(Poolid uint32, Node int) (Cpus int, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ccpus := C.int(0)
ret := C.libxl_cpupool_cpuremove_node(Ctx.ctx, C.uint32_t(Poolid), C.int(Node), &ccpus)
@@ -693,11 +666,6 @@ func (Ctx *Context) CpupoolCpuremoveNode(Poolid uint32, Node int) (Cpus int, err
// int libxl_cpupool_movedomain(libxl_ctx *ctx, uint32_t poolid, uint32_t domid);
func (Ctx *Context) CpupoolMovedomain(Poolid uint32, Id Domid) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ret := C.libxl_cpupool_movedomain(Ctx.ctx, C.uint32_t(Poolid), C.uint32_t(Id))
if ret != 0 {
err = Error(-ret)
@@ -857,60 +825,8 @@ func (bm Bitmap) String() (s string) {
return
}
-/*
- * Context
- */
-var Ctx Context
-
-func (Ctx *Context) IsOpen() bool {
- return Ctx.ctx != nil
-}
-
-func (Ctx *Context) Open() (err error) {
- if Ctx.ctx != nil {
- return
- }
-
- Ctx.logger = C.xtl_createlogger_stdiostream(C.stderr, C.XTL_ERROR, 0)
- if Ctx.logger == nil {
- err = fmt.Errorf("Cannot open stdiostream")
- return
- }
-
- ret := C.libxl_ctx_alloc(&Ctx.ctx, C.LIBXL_VERSION,
- 0, (*C.xentoollog_logger)(unsafe.Pointer(Ctx.logger)))
-
- if ret != 0 {
- err = Error(-ret)
- }
- return
-}
-
-func (Ctx *Context) Close() (err error) {
- ret := C.libxl_ctx_free(Ctx.ctx)
- Ctx.ctx = nil
-
- if ret != 0 {
- err = Error(-ret)
- }
- C.xtl_logger_destroy((*C.xentoollog_logger)(unsafe.Pointer(Ctx.logger)))
- return
-}
-
-func (Ctx *Context) CheckOpen() (err error) {
- if Ctx.ctx == nil {
- err = fmt.Errorf("Context not opened")
- }
- return
-}
-
//int libxl_get_max_cpus(libxl_ctx *ctx);
func (Ctx *Context) GetMaxCpus() (maxCpus int, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ret := C.libxl_get_max_cpus(Ctx.ctx)
if ret < 0 {
err = Error(-ret)
@@ -922,11 +838,6 @@ func (Ctx *Context) GetMaxCpus() (maxCpus int, err error) {
//int libxl_get_online_cpus(libxl_ctx *ctx);
func (Ctx *Context) GetOnlineCpus() (onCpus int, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ret := C.libxl_get_online_cpus(Ctx.ctx)
if ret < 0 {
err = Error(-ret)
@@ -938,10 +849,6 @@ func (Ctx *Context) GetOnlineCpus() (onCpus int, err error) {
//int libxl_get_max_nodes(libxl_ctx *ctx);
func (Ctx *Context) GetMaxNodes() (maxNodes int, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
ret := C.libxl_get_max_nodes(Ctx.ctx)
if ret < 0 {
err = Error(-ret)
@@ -953,10 +860,6 @@ func (Ctx *Context) GetMaxNodes() (maxNodes int, err error) {
//int libxl_get_free_memory(libxl_ctx *ctx, uint64_t *memkb);
func (Ctx *Context) GetFreeMemory() (memkb uint64, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
var cmem C.uint64_t
ret := C.libxl_get_free_memory(Ctx.ctx, &cmem)
@@ -972,10 +875,6 @@ func (Ctx *Context) GetFreeMemory() (memkb uint64, err error) {
//int libxl_get_physinfo(libxl_ctx *ctx, libxl_physinfo *physinfo)
func (Ctx *Context) GetPhysinfo() (physinfo *Physinfo, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
var cphys C.libxl_physinfo
C.libxl_physinfo_init(&cphys)
defer C.libxl_physinfo_dispose(&cphys)
@@ -993,11 +892,6 @@ func (Ctx *Context) GetPhysinfo() (physinfo *Physinfo, err error) {
//const libxl_version_info* libxl_get_version_info(libxl_ctx *ctx);
func (Ctx *Context) GetVersionInfo() (info *VersionInfo, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
var cinfo *C.libxl_version_info
cinfo = C.libxl_get_version_info(Ctx.ctx)
@@ -1008,11 +902,6 @@ func (Ctx *Context) GetVersionInfo() (info *VersionInfo, err error) {
}
func (Ctx *Context) DomainInfo(Id Domid) (di *Dominfo, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
var cdi C.libxl_dominfo
C.libxl_dominfo_init(&cdi)
defer C.libxl_dominfo_dispose(&cdi)
@@ -1030,11 +919,6 @@ func (Ctx *Context) DomainInfo(Id Domid) (di *Dominfo, err error) {
}
func (Ctx *Context) DomainUnpause(Id Domid) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ret := C.libxl_domain_unpause(Ctx.ctx, C.uint32_t(Id), nil)
if ret != 0 {
@@ -1045,11 +929,6 @@ func (Ctx *Context) DomainUnpause(Id Domid) (err error) {
//int libxl_domain_pause(libxl_ctx *ctx, uint32_t domain);
func (Ctx *Context) DomainPause(id Domid) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ret := C.libxl_domain_pause(Ctx.ctx, C.uint32_t(id), nil)
if ret != 0 {
@@ -1060,11 +939,6 @@ func (Ctx *Context) DomainPause(id Domid) (err error) {
//int libxl_domain_shutdown(libxl_ctx *ctx, uint32_t domid);
func (Ctx *Context) DomainShutdown(id Domid) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ret := C.libxl_domain_shutdown(Ctx.ctx, C.uint32_t(id), nil)
if ret != 0 {
@@ -1075,11 +949,6 @@ func (Ctx *Context) DomainShutdown(id Domid) (err error) {
//int libxl_domain_reboot(libxl_ctx *ctx, uint32_t domid);
func (Ctx *Context) DomainReboot(id Domid) (err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
ret := C.libxl_domain_reboot(Ctx.ctx, C.uint32_t(id), nil)
if ret != 0 {
@@ -1091,11 +960,6 @@ func (Ctx *Context) DomainReboot(id Domid) (err error) {
//libxl_dominfo * libxl_list_domain(libxl_ctx*, int *nb_domain_out);
//void libxl_dominfo_list_free(libxl_dominfo *list, int nb_domain);
func (Ctx *Context) ListDomain() (glist []Dominfo) {
- err := Ctx.CheckOpen()
- if err != nil {
- return
- }
-
var nbDomain C.int
clist := C.libxl_list_domain(Ctx.ctx, &nbDomain)
defer C.libxl_dominfo_list_free(clist, nbDomain)
@@ -1118,11 +982,6 @@ func (Ctx *Context) ListDomain() (glist []Dominfo) {
// int *nb_vcpu, int *nr_cpus_out);
//void libxl_vcpuinfo_list_free(libxl_vcpuinfo *, int nr_vcpus);
func (Ctx *Context) ListVcpu(id Domid) (glist []Vcpuinfo) {
- err := Ctx.CheckOpen()
- if err != nil {
- return
- }
-
var nbVcpu C.int
var nrCpu C.int
@@ -1153,11 +1012,6 @@ func (ct ConsoleType) String() (str string) {
//int libxl_console_get_tty(libxl_ctx *ctx, uint32_t domid, int cons_num,
//libxl_console_type type, char **path);
func (Ctx *Context) ConsoleGetTty(id Domid, consNum int, conType ConsoleType) (path string, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
var cpath *C.char
ret := C.libxl_console_get_tty(Ctx.ctx, C.uint32_t(id), C.int(consNum), C.libxl_console_type(conType), &cpath)
if ret != 0 {
@@ -1173,11 +1027,6 @@ func (Ctx *Context) ConsoleGetTty(id Domid, consNum int, conType ConsoleType) (p
//int libxl_primary_console_get_tty(libxl_ctx *ctx, uint32_t domid_vm,
// char **path);
func (Ctx *Context) PrimaryConsoleGetTty(domid uint32) (path string, err error) {
- err = Ctx.CheckOpen()
- if err != nil {
- return
- }
-
var cpath *C.char
ret := C.libxl_primary_console_get_tty(Ctx.ctx, C.uint32_t(domid), &cpath)
if ret != 0 {
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread* Re: [Xen-devel] [PATCH v3 21/22] golang/xenlight: revise use of Context type
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 21/22] golang/xenlight: revise use of Context type Nick Rosbrook
@ 2019-12-17 17:28 ` George Dunlap
0 siblings, 0 replies; 33+ messages in thread
From: George Dunlap @ 2019-12-17 17:28 UTC (permalink / raw)
To: Nick Rosbrook, xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, Wei Liu
On 12/10/19 3:47 PM, Nick Rosbrook wrote:
> From: Nick Rosbrook <rosbrookn@ainfosec.com>
>
> Remove the exported global context variable, 'Ctx.' Generally, it is
> better to not export global variables for use through a Go package.
> However, there are some exceptions that can be found in the standard
> library.
>
> Add a NewContext function instead, and remove the Open, IsOpen, and
> CheckOpen functions as a result.
>
> Also, comment-out an ineffectual assignment to 'err' inside the function
> Context.CpupoolInfo so that compilation does not fail.
>
> Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
Reviewed-by: George Dunlap <george.dunlap@citrix.com>
With one requested change...
> ---
> tools/golang/xenlight/xenlight.go | 219 +++++-------------------------
> 1 file changed, 34 insertions(+), 185 deletions(-)
>
> diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
> index f32eb11384..1c431fa4e5 100644
> --- a/tools/golang/xenlight/xenlight.go
> +++ b/tools/golang/xenlight/xenlight.go
> @@ -74,6 +74,39 @@ func (e Error) Error() string {
> return fmt.Sprintf("libxl error: %d", -e)
> }
>
> +// Context represents a libxl_ctx.
> +type Context struct {
> + ctx *C.libxl_ctx
> + logger *C.xentoollog_logger_stdiostream
> +}
> +
> +// NewContext returns a new Context.
> +func NewContext() (*Context, error) {
> + var ctx Context
> +
> + ctx.logger = C.xtl_createlogger_stdiostream(C.stderr, C.XTL_ERROR, 0)
> +
> + ret := C.libxl_ctx_alloc(&ctx.ctx, C.LIBXL_VERSION, 0, (*C.xentoollog_logger)(unsafe.Pointer(ctx.logger)))
This line looks to be 114 characters long, which seems a bit much. :-)
Mind breaking it just before the last argument?
Thanks,
-George
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 33+ messages in thread
* [Xen-devel] [PATCH v3 22/22] golang/xenlight: add error return type to Context.Cpupoolinfo
2019-12-10 15:47 [Xen-devel] [PATCH v3 00/22] generated Go libxl bindings using IDL Nick Rosbrook
` (20 preceding siblings ...)
2019-12-10 15:47 ` [Xen-devel] [PATCH v3 21/22] golang/xenlight: revise use of Context type Nick Rosbrook
@ 2019-12-10 15:47 ` Nick Rosbrook
2019-12-17 17:29 ` George Dunlap
21 siblings, 1 reply; 33+ messages in thread
From: Nick Rosbrook @ 2019-12-10 15:47 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, kerriganb, George Dunlap, Wei Liu
From: Nick Rosbrook <rosbrookn@ainfosec.com>
A previous commit that removed Context.CheckOpen revealed
an ineffectual assignent to err in Context.Cpupoolinfo, as
there is no error return type.
Since it appears that the intent is to return an error here,
add an error return value to the function signature.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
tools/golang/xenlight/xenlight.go | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 1c431fa4e5..38d2ba8aa8 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -503,17 +503,17 @@ func (Ctx *Context) ListCpupool() (list []Cpupoolinfo) {
}
// int libxl_cpupool_info(libxl_ctx *ctx, libxl_cpupoolinfo *info, uint32_t poolid);
-func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool Cpupoolinfo) {
+func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool Cpupoolinfo, err error) {
var c_cpupool C.libxl_cpupoolinfo
ret := C.libxl_cpupool_info(Ctx.ctx, &c_cpupool, C.uint32_t(Poolid))
if ret != 0 {
- //err = Error(-ret)
+ err = Error(-ret)
return
}
defer C.libxl_cpupoolinfo_dispose(&c_cpupool)
- _ = pool.fromC(&c_cpupool)
+ err = pool.fromC(&c_cpupool)
return
}
--
2.19.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 33+ messages in thread