* [Xen-devel] [PATCH v5 0/3] generated Go libxl bindings using IDL
@ 2020-01-04 21:00 Nick Rosbrook
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 1/3] golang/xenlight: begin Go to C type marshaling Nick Rosbrook
` (2 more replies)
0 siblings, 3 replies; 9+ messages in thread
From: Nick Rosbrook @ 2020-01-04 21:00 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, George Dunlap, Wei Liu
After Xen summit, we started the discussion in this[1] RFC thread
to figure out how to generate Go bindings for libxl. This series
implements that Go code generation using the existing IDL, and updates
the existing hand-written code in xenlight.go to use the generated
code.
The goal of this series is to provide a good foundation for continued
development of the Go package.
The v1 series can be found on my GitHub branch[2].
Changes in v2:
- GitHub branch for v2 [3].
- Drop patch 01/24 from v1 since was committed as a bug fix for 4.13.
- The Makefile changes in 24/24 from v1 have been moved to the patches
where the build changes are introduced.
Changes in v3:
- GitHub branch for v3 [4].
- Simplify a pattern for iterating over builtin types
in their fromC functions.
- Try not to duplicate as much code in gengotypes.py, and
use consistent style in generated code when calling fromC.
Changes in v4:
- GitHub branch for v4 [5].
- The first 16 patches were commited after v3.
Changes in v5:
- GitHub branch for v5 [6].
- The only 3 patches left are for generating toC marshaling functions.
[1] https://lists.xenproject.org/archives/html/xen-devel/2019-07/msg02259.html
[2] https://github.com/enr0n/xen/tree/golang-patches-v1
[3] https://github.com/enr0n/xen/tree/golang-patches-v2
[4] https://github.com/enr0n/xen/tree/golang-patches-v3
[5] https://github.com/enr0n/xen/tree/golang-patches-v4
[6] https://github.com/enr0n/xen/tree/golang-patches-v5
Nick Rosbrook (3):
golang/xenlight: begin Go to C type marshaling
golang/xenlight: implement keyed union Go to C marshaling
golang/xenlight: implement array Go to C marshaling
tools/golang/xenlight/gengotypes.py | 185 +++
tools/golang/xenlight/helpers.gen.go | 2249 +++++++++++++++++++++++++-
tools/golang/xenlight/xenlight.go | 82 +-
3 files changed, 2399 insertions(+), 117 deletions(-)
--
2.17.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 9+ messages in thread
* [Xen-devel] [PATCH v5 1/3] golang/xenlight: begin Go to C type marshaling
2020-01-04 21:00 [Xen-devel] [PATCH v5 0/3] generated Go libxl bindings using IDL Nick Rosbrook
@ 2020-01-04 21:00 ` Nick Rosbrook
2020-01-16 16:00 ` George Dunlap
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 2/3] golang/xenlight: implement keyed union Go to C marshaling Nick Rosbrook
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 3/3] golang/xenlight: implement array " Nick Rosbrook
2 siblings, 1 reply; 9+ messages in thread
From: Nick Rosbrook @ 2020-01-04 21:00 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, George Dunlap, Wei Liu
Implement conversions for basic types such as strings and integer
types in toC functions.
Modify function signatures of toC implementations for builtin
types to be consistent with the signature of the generated toC
functions.
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
Changes in v5:
- Define xenlight_golang_convert_to_C so that field conversion code
can be easily re-used.
- Check for err in defer'd func within toC to determine if the dispose
function needs to be called.
- Pass a reference to the C type in toC, rather than returning a copy
of the C variable.
- Update the existing toC functions for builtin types to be consistent
with the generated functions.
- Only call CString if the Go string is non-empty.
---
tools/golang/xenlight/gengotypes.py | 81 ++
tools/golang/xenlight/helpers.gen.go | 1506 ++++++++++++++++++++++++++
tools/golang/xenlight/xenlight.go | 82 +-
3 files changed, 1621 insertions(+), 48 deletions(-)
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
index 8857e2e8fd..15aa4be220 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):
@@ -434,6 +437,84 @@ def xenlight_golang_array_from_C(ty = None):
return s
+def xenlight_golang_define_to_C(ty = None, typename = None, nested = False):
+ """
+ Define the toC marshaling function for the type
+ represented by ty.
+ """
+ func = 'func (x *{}) toC(xc *C.{}) (err error){{{}\n return nil \n }}\n'
+ body = ''
+
+ if ty.dispose_fn is not None:
+ body += 'defer func(){{\nif err != nil{{\nC.{}(xc)}}\n}}()\n\n'.format(ty.dispose_fn)
+
+ goname = xenlight_golang_fmt_name(ty.typename)
+ cname = ty.typename
+
+ for f in ty.fields:
+ if f.type.typename is not None:
+ if isinstance(f.type, idl.Array):
+ # TODO
+ continue
+
+ body += xenlight_golang_convert_to_C(f)
+
+ elif isinstance(f.type, idl.Struct):
+ for nf in f.type.fields:
+ body += xenlight_golang_convert_to_C(nf, outer_name=f.name)
+
+ elif isinstance(f.type, idl.KeyedUnion):
+ # TODO
+ pass
+
+ else:
+ raise Exception('type {} not supported'.format(f.type))
+
+ return func.format(goname, cname, body)
+
+def xenlight_golang_convert_to_C(ty = None, outer_name = None):
+ """
+ Returns a line of Go code that converts the Go 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)
+ ctypename = 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)
+
+ 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:
+ s += 'if err := x.{}.toC(&xc.{}); err != nil {{\n'.format(goname,cname)
+ s += 'return err\n}\n'
+
+ elif gotypename == 'string':
+ # Use the cgo helper for converting C strings.
+ s += 'if x.{} != "" {{\n'.format(goname)
+ s += 'xc.{} = C.CString(x.{})}}\n'.format(cname,goname)
+
+ else:
+ s += 'xc.{} = C.{}(x.{})\n'.format(cname,ctypename,goname)
+
+ 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 25294ba292..30cd1a9b3f 100644
--- a/tools/golang/xenlight/helpers.gen.go
+++ b/tools/golang/xenlight/helpers.gen.go
@@ -37,6 +37,19 @@ func (x *IoportRange) fromC(xc *C.libxl_ioport_range) error {
return nil
}
+func (x *IoportRange) toC(xc *C.libxl_ioport_range) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_ioport_range_dispose(xc)
+ }
+ }()
+
+ xc.first = C.uint32_t(x.First)
+ xc.number = C.uint32_t(x.Number)
+
+ return nil
+}
+
func (x *IomemRange) fromC(xc *C.libxl_iomem_range) error {
x.Start = uint64(xc.start)
x.Number = uint64(xc.number)
@@ -45,12 +58,38 @@ func (x *IomemRange) fromC(xc *C.libxl_iomem_range) error {
return nil
}
+func (x *IomemRange) toC(xc *C.libxl_iomem_range) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_iomem_range_dispose(xc)
+ }
+ }()
+
+ xc.start = C.uint64_t(x.Start)
+ xc.number = C.uint64_t(x.Number)
+ xc.gfn = C.uint64_t(x.Gfn)
+
+ return 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) {
+ defer func() {
+ if err != nil {
+ C.libxl_vga_interface_info_dispose(xc)
+ }
+ }()
+
+ xc.kind = C.libxl_vga_interface_type(x.Kind)
+
+ return nil
+}
+
func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error {
if err := x.Enable.fromC(&xc.enable); err != nil {
return err
@@ -65,6 +104,30 @@ func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error {
return nil
}
+func (x *VncInfo) toC(xc *C.libxl_vnc_info) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vnc_info_dispose(xc)
+ }
+ }()
+
+ if err := x.Enable.toC(&xc.enable); err != nil {
+ return err
+ }
+ if x.Listen != "" {
+ xc.listen = C.CString(x.Listen)
+ }
+ if x.Passwd != "" {
+ xc.passwd = C.CString(x.Passwd)
+ }
+ xc.display = C.int(x.Display)
+ if err := x.Findunused.toC(&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
@@ -92,6 +155,47 @@ func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error {
return nil
}
+func (x *SpiceInfo) toC(xc *C.libxl_spice_info) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_spice_info_dispose(xc)
+ }
+ }()
+
+ if err := x.Enable.toC(&xc.enable); err != nil {
+ return err
+ }
+ xc.port = C.int(x.Port)
+ xc.tls_port = C.int(x.TlsPort)
+ if x.Host != "" {
+ xc.host = C.CString(x.Host)
+ }
+ if err := x.DisableTicketing.toC(&xc.disable_ticketing); err != nil {
+ return err
+ }
+ if x.Passwd != "" {
+ xc.passwd = C.CString(x.Passwd)
+ }
+ if err := x.AgentMouse.toC(&xc.agent_mouse); err != nil {
+ return err
+ }
+ if err := x.Vdagent.toC(&xc.vdagent); err != nil {
+ return err
+ }
+ if err := x.ClipboardSharing.toC(&xc.clipboard_sharing); err != nil {
+ return err
+ }
+ xc.usbredirection = C.int(x.Usbredirection)
+ if x.ImageCompression != "" {
+ xc.image_compression = C.CString(x.ImageCompression)
+ }
+ if x.StreamingVideo != "" {
+ xc.streaming_video = C.CString(x.StreamingVideo)
+ }
+
+ return nil
+}
+
func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error {
if err := x.Enable.fromC(&xc.enable); err != nil {
return err
@@ -105,6 +209,29 @@ func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error {
return nil
}
+func (x *SdlInfo) toC(xc *C.libxl_sdl_info) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_sdl_info_dispose(xc)
+ }
+ }()
+
+ if err := x.Enable.toC(&xc.enable); err != nil {
+ return err
+ }
+ if err := x.Opengl.toC(&xc.opengl); err != nil {
+ return err
+ }
+ if x.Display != "" {
+ xc.display = C.CString(x.Display)
+ }
+ if x.Xauthority != "" {
+ xc.xauthority = C.CString(x.Xauthority)
+ }
+
+ return nil
+}
+
func (x *Dominfo) fromC(xc *C.libxl_dominfo) error {
if err := x.Uuid.fromC(&xc.uuid); err != nil {
return err
@@ -133,6 +260,42 @@ func (x *Dominfo) fromC(xc *C.libxl_dominfo) error {
return nil
}
+func (x *Dominfo) toC(xc *C.libxl_dominfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_dominfo_dispose(xc)
+ }
+ }()
+
+ if err := x.Uuid.toC(&xc.uuid); err != nil {
+ return err
+ }
+ xc.domid = C.libxl_domid(x.Domid)
+ xc.ssidref = C.uint32_t(x.Ssidref)
+ if x.SsidLabel != "" {
+ 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 nil
+}
+
func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) error {
x.Poolid = uint32(xc.poolid)
x.PoolName = C.GoString(xc.pool_name)
@@ -145,6 +308,26 @@ func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) error {
return nil
}
+func (x *Cpupoolinfo) toC(xc *C.libxl_cpupoolinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_cpupoolinfo_dispose(xc)
+ }
+ }()
+
+ xc.poolid = C.uint32_t(x.Poolid)
+ if x.PoolName != "" {
+ xc.pool_name = C.CString(x.PoolName)
+ }
+ xc.sched = C.libxl_scheduler(x.Sched)
+ xc.n_dom = C.uint32_t(x.NDom)
+ if err := x.Cpumap.toC(&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)
@@ -179,6 +362,29 @@ func (x *ChannelinfoConnectionUnionPty) fromC(xc *C.libxl_channelinfo) error {
return nil
}
+func (x *Channelinfo) toC(xc *C.libxl_channelinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_channelinfo_dispose(xc)
+ }
+ }()
+
+ if x.Backend != "" {
+ xc.backend = C.CString(x.Backend)
+ }
+ xc.backend_id = C.uint32_t(x.BackendId)
+ if x.Frontend != "" {
+ 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 nil
+}
+
func (x *Vminfo) fromC(xc *C.libxl_vminfo) error {
if err := x.Uuid.fromC(&xc.uuid); err != nil {
return err
@@ -188,6 +394,21 @@ func (x *Vminfo) fromC(xc *C.libxl_vminfo) error {
return nil
}
+func (x *Vminfo) toC(xc *C.libxl_vminfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vminfo_dispose(xc)
+ }
+ }()
+
+ if err := x.Uuid.toC(&xc.uuid); err != nil {
+ return err
+ }
+ xc.domid = C.libxl_domid(x.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)
@@ -206,6 +427,48 @@ func (x *VersionInfo) fromC(xc *C.libxl_version_info) error {
return nil
}
+func (x *VersionInfo) toC(xc *C.libxl_version_info) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_version_info_dispose(xc)
+ }
+ }()
+
+ xc.xen_version_major = C.int(x.XenVersionMajor)
+ xc.xen_version_minor = C.int(x.XenVersionMinor)
+ if x.XenVersionExtra != "" {
+ xc.xen_version_extra = C.CString(x.XenVersionExtra)
+ }
+ if x.Compiler != "" {
+ xc.compiler = C.CString(x.Compiler)
+ }
+ if x.CompileBy != "" {
+ xc.compile_by = C.CString(x.CompileBy)
+ }
+ if x.CompileDomain != "" {
+ xc.compile_domain = C.CString(x.CompileDomain)
+ }
+ if x.CompileDate != "" {
+ xc.compile_date = C.CString(x.CompileDate)
+ }
+ if x.Capabilities != "" {
+ xc.capabilities = C.CString(x.Capabilities)
+ }
+ if x.Changeset != "" {
+ xc.changeset = C.CString(x.Changeset)
+ }
+ xc.virt_start = C.uint64_t(x.VirtStart)
+ xc.pagesize = C.int(x.Pagesize)
+ if x.Commandline != "" {
+ xc.commandline = C.CString(x.Commandline)
+ }
+ if x.BuildId != "" {
+ xc.build_id = C.CString(x.BuildId)
+ }
+
+ 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 {
@@ -239,6 +502,51 @@ 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) {
+ defer func() {
+ if err != nil {
+ C.libxl_domain_create_info_dispose(xc)
+ }
+ }()
+
+ xc._type = C.libxl_domain_type(x.Type)
+ if err := x.Hap.toC(&xc.hap); err != nil {
+ return err
+ }
+ if err := x.Oos.toC(&xc.oos); err != nil {
+ return err
+ }
+ xc.ssidref = C.uint32_t(x.Ssidref)
+ if x.SsidLabel != "" {
+ xc.ssid_label = C.CString(x.SsidLabel)
+ }
+ if x.Name != "" {
+ xc.name = C.CString(x.Name)
+ }
+ if err := x.Uuid.toC(&xc.uuid); err != nil {
+ return err
+ }
+ if err := x.Xsdata.toC(&xc.xsdata); err != nil {
+ return err
+ }
+ if err := x.Platformdata.toC(&xc.platformdata); err != nil {
+ return err
+ }
+ xc.poolid = C.uint32_t(x.Poolid)
+ if x.PoolName != "" {
+ xc.pool_name = C.CString(x.PoolName)
+ }
+ if err := x.RunHotplugScripts.toC(&xc.run_hotplug_scripts); err != nil {
+ return err
+ }
+ if err := x.DriverDomain.toC(&xc.driver_domain); err != nil {
+ return err
+ }
+ xc.passthrough = C.libxl_passthrough(x.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)
@@ -250,6 +558,25 @@ 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) {
+ defer func() {
+ if err != nil {
+ C.libxl_domain_restore_params_dispose(xc)
+ }
+ }()
+
+ xc.checkpointed_stream = C.int(x.CheckpointedStream)
+ xc.stream_version = C.uint32_t(x.StreamVersion)
+ if x.ColoProxyScript != "" {
+ xc.colo_proxy_script = C.CString(x.ColoProxyScript)
+ }
+ if err := x.UserspaceColoProxy.toC(&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)
@@ -261,6 +588,23 @@ func (x *SchedParams) fromC(xc *C.libxl_sched_params) error {
return nil
}
+func (x *SchedParams) toC(xc *C.libxl_sched_params) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_sched_params_dispose(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 nil
+}
+
func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
x.Sched = Scheduler(xc.sched)
numVcpus := int(xc.num_vcpus)
@@ -275,6 +619,18 @@ 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) {
+ defer func() {
+ if err != nil {
+ C.libxl_vcpu_sched_params_dispose(xc)
+ }
+ }()
+
+ xc.sched = C.libxl_scheduler(x.Sched)
+
+ return nil
+}
+
func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error {
x.Sched = Scheduler(xc.sched)
x.Weight = int(xc.weight)
@@ -288,6 +644,25 @@ 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) {
+ defer func() {
+ if err != nil {
+ C.libxl_domain_sched_params_dispose(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 nil
+}
+
func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error {
x.Memkb = uint64(xc.memkb)
numDistances := int(xc.num_distances)
@@ -304,6 +679,22 @@ func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error {
return nil
}
+func (x *VnodeInfo) toC(xc *C.libxl_vnode_info) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vnode_info_dispose(xc)
+ }
+ }()
+
+ xc.memkb = C.uint64_t(x.Memkb)
+ xc.pnode = C.uint32_t(x.Pnode)
+ if err := x.Vcpus.toC(&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)
@@ -311,6 +702,19 @@ func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) error {
return nil
}
+func (x *RdmReserve) toC(xc *C.libxl_rdm_reserve) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_rdm_reserve_dispose(xc)
+ }
+ }()
+
+ xc.strategy = C.libxl_rdm_reserve_strategy(x.Strategy)
+ xc.policy = C.libxl_rdm_reserve_policy(x.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 {
@@ -613,6 +1017,120 @@ 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) {
+ defer func() {
+ if err != nil {
+ C.libxl_domain_build_info_dispose(xc)
+ }
+ }()
+
+ xc.max_vcpus = C.int(x.MaxVcpus)
+ if err := x.AvailVcpus.toC(&xc.avail_vcpus); err != nil {
+ return err
+ }
+ if err := x.Cpumap.toC(&xc.cpumap); err != nil {
+ return err
+ }
+ if err := x.Nodemap.toC(&xc.nodemap); err != nil {
+ return err
+ }
+ if err := x.NumaPlacement.toC(&xc.numa_placement); err != nil {
+ return 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)
+ if x.ExecSsidLabel != "" {
+ xc.exec_ssid_label = C.CString(x.ExecSsidLabel)
+ }
+ if err := x.Localtime.toC(&xc.localtime); err != nil {
+ return err
+ }
+ if err := x.DisableMigrate.toC(&xc.disable_migrate); err != nil {
+ return err
+ }
+ if err := x.Cpuid.toC(&xc.cpuid); err != nil {
+ return err
+ }
+ if x.BlkdevStart != "" {
+ 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)
+ if err := x.DeviceModelStubdomain.toC(&xc.device_model_stubdomain); err != nil {
+ return err
+ }
+ if x.DeviceModel != "" {
+ xc.device_model = C.CString(x.DeviceModel)
+ }
+ xc.device_model_ssidref = C.uint32_t(x.DeviceModelSsidref)
+ if x.DeviceModelSsidLabel != "" {
+ xc.device_model_ssid_label = C.CString(x.DeviceModelSsidLabel)
+ }
+ if x.DeviceModelUser != "" {
+ xc.device_model_user = C.CString(x.DeviceModelUser)
+ }
+ if err := x.Extra.toC(&xc.extra); err != nil {
+ return err
+ }
+ if err := x.ExtraPv.toC(&xc.extra_pv); err != nil {
+ return err
+ }
+ if err := x.ExtraHvm.toC(&xc.extra_hvm); err != nil {
+ return err
+ }
+ if err := x.SchedParams.toC(&xc.sched_params); err != nil {
+ return err
+ }
+ if err := x.ClaimMode.toC(&xc.claim_mode); err != nil {
+ return err
+ }
+ xc.event_channels = C.uint32_t(x.EventChannels)
+ if x.Kernel != "" {
+ xc.kernel = C.CString(x.Kernel)
+ }
+ if x.Cmdline != "" {
+ xc.cmdline = C.CString(x.Cmdline)
+ }
+ if x.Ramdisk != "" {
+ xc.ramdisk = C.CString(x.Ramdisk)
+ }
+ if x.DeviceTree != "" {
+ xc.device_tree = C.CString(x.DeviceTree)
+ }
+ if err := x.Acpi.toC(&xc.acpi); err != nil {
+ return err
+ }
+ if x.Bootloader != "" {
+ xc.bootloader = C.CString(x.Bootloader)
+ }
+ if err := x.BootloaderArgs.toC(&xc.bootloader_args); err != nil {
+ return err
+ }
+ xc.timer_mode = C.libxl_timer_mode(x.TimerMode)
+ if err := x.NestedHvm.toC(&xc.nested_hvm); err != nil {
+ return err
+ }
+ if err := x.Apic.toC(&xc.apic); err != nil {
+ return err
+ }
+ if err := x.DmRestrict.toC(&xc.dm_restrict); err != nil {
+ return 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 nil
+}
+
func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -628,6 +1146,31 @@ func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) error {
return nil
}
+func (x *DeviceVfb) toC(xc *C.libxl_device_vfb) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_vfb_dispose(xc)
+ }
+ }()
+
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+ xc.devid = C.libxl_devid(x.Devid)
+ if err := x.Vnc.toC(&xc.vnc); err != nil {
+ return err
+ }
+ if err := x.Sdl.toC(&xc.sdl); err != nil {
+ return err
+ }
+ if x.Keymap != "" {
+ xc.keymap = C.CString(x.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)
@@ -648,6 +1191,36 @@ func (x *DeviceVkb) fromC(xc *C.libxl_device_vkb) error {
return nil
}
+func (x *DeviceVkb) toC(xc *C.libxl_device_vkb) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_vkb_dispose(xc)
+ }
+ }()
+
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.backend_type = C.libxl_vkb_backend(x.BackendType)
+ if x.UniqueId != "" {
+ 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 nil
+}
+
func (x *DeviceDisk) fromC(xc *C.libxl_device_disk) error {
x.BackendDomid = Domid(xc.backend_domid)
x.BackendDomname = C.GoString(xc.backend_domname)
@@ -678,6 +1251,58 @@ func (x *DeviceDisk) fromC(xc *C.libxl_device_disk) error {
return nil
}
+func (x *DeviceDisk) toC(xc *C.libxl_device_disk) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_disk_dispose(xc)
+ }
+ }()
+
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+ if x.PdevPath != "" {
+ xc.pdev_path = C.CString(x.PdevPath)
+ }
+ if x.Vdev != "" {
+ xc.vdev = C.CString(x.Vdev)
+ }
+ xc.backend = C.libxl_disk_backend(x.Backend)
+ xc.format = C.libxl_disk_format(x.Format)
+ if x.Script != "" {
+ 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)
+ if err := x.DiscardEnable.toC(&xc.discard_enable); err != nil {
+ return err
+ }
+ if err := x.ColoEnable.toC(&xc.colo_enable); err != nil {
+ return err
+ }
+ if err := x.ColoRestoreEnable.toC(&xc.colo_restore_enable); err != nil {
+ return err
+ }
+ if x.ColoHost != "" {
+ xc.colo_host = C.CString(x.ColoHost)
+ }
+ xc.colo_port = C.int(x.ColoPort)
+ if x.ColoExport != "" {
+ xc.colo_export = C.CString(x.ColoExport)
+ }
+ if x.ActiveDisk != "" {
+ xc.active_disk = C.CString(x.ActiveDisk)
+ }
+ if x.HiddenDisk != "" {
+ xc.hidden_disk = C.CString(x.HiddenDisk)
+ }
+
+ 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)
@@ -748,6 +1373,194 @@ func (x *DeviceNic) fromC(xc *C.libxl_device_nic) error {
return nil
}
+func (x *DeviceNic) toC(xc *C.libxl_device_nic) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_nic_dispose(xc)
+ }
+ }()
+
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.mtu = C.int(x.Mtu)
+ if x.Model != "" {
+ xc.model = C.CString(x.Model)
+ }
+ if err := x.Mac.toC(&xc.mac); err != nil {
+ return err
+ }
+ if x.Ip != "" {
+ xc.ip = C.CString(x.Ip)
+ }
+ if x.Bridge != "" {
+ xc.bridge = C.CString(x.Bridge)
+ }
+ if x.Ifname != "" {
+ xc.ifname = C.CString(x.Ifname)
+ }
+ if x.Script != "" {
+ 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)
+ if x.Gatewaydev != "" {
+ xc.gatewaydev = C.CString(x.Gatewaydev)
+ }
+ if x.ColoftForwarddev != "" {
+ xc.coloft_forwarddev = C.CString(x.ColoftForwarddev)
+ }
+ if x.ColoSockMirrorId != "" {
+ xc.colo_sock_mirror_id = C.CString(x.ColoSockMirrorId)
+ }
+ if x.ColoSockMirrorIp != "" {
+ xc.colo_sock_mirror_ip = C.CString(x.ColoSockMirrorIp)
+ }
+ if x.ColoSockMirrorPort != "" {
+ xc.colo_sock_mirror_port = C.CString(x.ColoSockMirrorPort)
+ }
+ if x.ColoSockComparePriInId != "" {
+ xc.colo_sock_compare_pri_in_id = C.CString(x.ColoSockComparePriInId)
+ }
+ if x.ColoSockComparePriInIp != "" {
+ xc.colo_sock_compare_pri_in_ip = C.CString(x.ColoSockComparePriInIp)
+ }
+ if x.ColoSockComparePriInPort != "" {
+ xc.colo_sock_compare_pri_in_port = C.CString(x.ColoSockComparePriInPort)
+ }
+ if x.ColoSockCompareSecInId != "" {
+ xc.colo_sock_compare_sec_in_id = C.CString(x.ColoSockCompareSecInId)
+ }
+ if x.ColoSockCompareSecInIp != "" {
+ xc.colo_sock_compare_sec_in_ip = C.CString(x.ColoSockCompareSecInIp)
+ }
+ if x.ColoSockCompareSecInPort != "" {
+ xc.colo_sock_compare_sec_in_port = C.CString(x.ColoSockCompareSecInPort)
+ }
+ if x.ColoSockCompareNotifyId != "" {
+ xc.colo_sock_compare_notify_id = C.CString(x.ColoSockCompareNotifyId)
+ }
+ if x.ColoSockCompareNotifyIp != "" {
+ xc.colo_sock_compare_notify_ip = C.CString(x.ColoSockCompareNotifyIp)
+ }
+ if x.ColoSockCompareNotifyPort != "" {
+ xc.colo_sock_compare_notify_port = C.CString(x.ColoSockCompareNotifyPort)
+ }
+ if x.ColoSockRedirector0Id != "" {
+ xc.colo_sock_redirector0_id = C.CString(x.ColoSockRedirector0Id)
+ }
+ if x.ColoSockRedirector0Ip != "" {
+ xc.colo_sock_redirector0_ip = C.CString(x.ColoSockRedirector0Ip)
+ }
+ if x.ColoSockRedirector0Port != "" {
+ xc.colo_sock_redirector0_port = C.CString(x.ColoSockRedirector0Port)
+ }
+ if x.ColoSockRedirector1Id != "" {
+ xc.colo_sock_redirector1_id = C.CString(x.ColoSockRedirector1Id)
+ }
+ if x.ColoSockRedirector1Ip != "" {
+ xc.colo_sock_redirector1_ip = C.CString(x.ColoSockRedirector1Ip)
+ }
+ if x.ColoSockRedirector1Port != "" {
+ xc.colo_sock_redirector1_port = C.CString(x.ColoSockRedirector1Port)
+ }
+ if x.ColoSockRedirector2Id != "" {
+ xc.colo_sock_redirector2_id = C.CString(x.ColoSockRedirector2Id)
+ }
+ if x.ColoSockRedirector2Ip != "" {
+ xc.colo_sock_redirector2_ip = C.CString(x.ColoSockRedirector2Ip)
+ }
+ if x.ColoSockRedirector2Port != "" {
+ xc.colo_sock_redirector2_port = C.CString(x.ColoSockRedirector2Port)
+ }
+ if x.ColoFilterMirrorQueue != "" {
+ xc.colo_filter_mirror_queue = C.CString(x.ColoFilterMirrorQueue)
+ }
+ if x.ColoFilterMirrorOutdev != "" {
+ xc.colo_filter_mirror_outdev = C.CString(x.ColoFilterMirrorOutdev)
+ }
+ if x.ColoFilterRedirector0Queue != "" {
+ xc.colo_filter_redirector0_queue = C.CString(x.ColoFilterRedirector0Queue)
+ }
+ if x.ColoFilterRedirector0Indev != "" {
+ xc.colo_filter_redirector0_indev = C.CString(x.ColoFilterRedirector0Indev)
+ }
+ if x.ColoFilterRedirector0Outdev != "" {
+ xc.colo_filter_redirector0_outdev = C.CString(x.ColoFilterRedirector0Outdev)
+ }
+ if x.ColoFilterRedirector1Queue != "" {
+ xc.colo_filter_redirector1_queue = C.CString(x.ColoFilterRedirector1Queue)
+ }
+ if x.ColoFilterRedirector1Indev != "" {
+ xc.colo_filter_redirector1_indev = C.CString(x.ColoFilterRedirector1Indev)
+ }
+ if x.ColoFilterRedirector1Outdev != "" {
+ xc.colo_filter_redirector1_outdev = C.CString(x.ColoFilterRedirector1Outdev)
+ }
+ if x.ColoComparePriIn != "" {
+ xc.colo_compare_pri_in = C.CString(x.ColoComparePriIn)
+ }
+ if x.ColoCompareSecIn != "" {
+ xc.colo_compare_sec_in = C.CString(x.ColoCompareSecIn)
+ }
+ if x.ColoCompareOut != "" {
+ xc.colo_compare_out = C.CString(x.ColoCompareOut)
+ }
+ if x.ColoCompareNotifyDev != "" {
+ xc.colo_compare_notify_dev = C.CString(x.ColoCompareNotifyDev)
+ }
+ if x.ColoSockSecRedirector0Id != "" {
+ xc.colo_sock_sec_redirector0_id = C.CString(x.ColoSockSecRedirector0Id)
+ }
+ if x.ColoSockSecRedirector0Ip != "" {
+ xc.colo_sock_sec_redirector0_ip = C.CString(x.ColoSockSecRedirector0Ip)
+ }
+ if x.ColoSockSecRedirector0Port != "" {
+ xc.colo_sock_sec_redirector0_port = C.CString(x.ColoSockSecRedirector0Port)
+ }
+ if x.ColoSockSecRedirector1Id != "" {
+ xc.colo_sock_sec_redirector1_id = C.CString(x.ColoSockSecRedirector1Id)
+ }
+ if x.ColoSockSecRedirector1Ip != "" {
+ xc.colo_sock_sec_redirector1_ip = C.CString(x.ColoSockSecRedirector1Ip)
+ }
+ if x.ColoSockSecRedirector1Port != "" {
+ xc.colo_sock_sec_redirector1_port = C.CString(x.ColoSockSecRedirector1Port)
+ }
+ if x.ColoFilterSecRedirector0Queue != "" {
+ xc.colo_filter_sec_redirector0_queue = C.CString(x.ColoFilterSecRedirector0Queue)
+ }
+ if x.ColoFilterSecRedirector0Indev != "" {
+ xc.colo_filter_sec_redirector0_indev = C.CString(x.ColoFilterSecRedirector0Indev)
+ }
+ if x.ColoFilterSecRedirector0Outdev != "" {
+ xc.colo_filter_sec_redirector0_outdev = C.CString(x.ColoFilterSecRedirector0Outdev)
+ }
+ if x.ColoFilterSecRedirector1Queue != "" {
+ xc.colo_filter_sec_redirector1_queue = C.CString(x.ColoFilterSecRedirector1Queue)
+ }
+ if x.ColoFilterSecRedirector1Indev != "" {
+ xc.colo_filter_sec_redirector1_indev = C.CString(x.ColoFilterSecRedirector1Indev)
+ }
+ if x.ColoFilterSecRedirector1Outdev != "" {
+ xc.colo_filter_sec_redirector1_outdev = C.CString(x.ColoFilterSecRedirector1Outdev)
+ }
+ if x.ColoFilterSecRewriter0Queue != "" {
+ xc.colo_filter_sec_rewriter0_queue = C.CString(x.ColoFilterSecRewriter0Queue)
+ }
+ if x.ColoCheckpointHost != "" {
+ xc.colo_checkpoint_host = C.CString(x.ColoCheckpointHost)
+ }
+ if x.ColoCheckpointPort != "" {
+ xc.colo_checkpoint_port = C.CString(x.ColoCheckpointPort)
+ }
+
+ return nil
+}
+
func (x *DevicePci) fromC(xc *C.libxl_device_pci) error {
x.Func = byte(xc._func)
x.Dev = byte(xc.dev)
@@ -764,6 +1577,28 @@ func (x *DevicePci) fromC(xc *C.libxl_device_pci) error {
return nil
}
+func (x *DevicePci) toC(xc *C.libxl_device_pci) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_pci_dispose(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 nil
+}
+
func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) error {
x.Start = uint64(xc.start)
x.Size = uint64(xc.size)
@@ -772,6 +1607,20 @@ func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) error {
return nil
}
+func (x *DeviceRdm) toC(xc *C.libxl_device_rdm) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_rdm_dispose(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 nil
+}
+
func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error {
x.Type = UsbctrlType(xc._type)
x.Devid = Devid(xc.devid)
@@ -783,6 +1632,25 @@ func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error {
return nil
}
+func (x *DeviceUsbctrl) toC(xc *C.libxl_device_usbctrl) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_usbctrl_dispose(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)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+
+ return nil
+}
+
func (x *DeviceUsbdev) fromC(xc *C.libxl_device_usbdev) error {
x.Ctrl = Devid(xc.ctrl)
x.Port = int(xc.port)
@@ -812,12 +1680,39 @@ func (x *DeviceUsbdevTypeUnionHostdev) fromC(xc *C.libxl_device_usbdev) error {
return nil
}
+func (x *DeviceUsbdev) toC(xc *C.libxl_device_usbdev) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_usbdev_dispose(xc)
+ }
+ }()
+
+ xc.ctrl = C.libxl_devid(x.Ctrl)
+ xc.port = C.int(x.Port)
+
+ return 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) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_dtdev_dispose(xc)
+ }
+ }()
+
+ if x.Path != "" {
+ xc.path = C.CString(x.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)
@@ -829,6 +1724,25 @@ func (x *DeviceVtpm) fromC(xc *C.libxl_device_vtpm) error {
return nil
}
+func (x *DeviceVtpm) toC(xc *C.libxl_device_vtpm) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_vtpm_dispose(xc)
+ }
+ }()
+
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+ xc.devid = C.libxl_devid(x.Devid)
+ if err := x.Uuid.toC(&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)
@@ -840,6 +1754,31 @@ func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error {
return nil
}
+func (x *DeviceP9) toC(xc *C.libxl_device_p9) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_p9_dispose(xc)
+ }
+ }()
+
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+ if x.Tag != "" {
+ xc.tag = C.CString(x.Tag)
+ }
+ if x.Path != "" {
+ xc.path = C.CString(x.Path)
+ }
+ if x.SecurityModel != "" {
+ xc.security_model = C.CString(x.SecurityModel)
+ }
+ xc.devid = C.libxl_devid(x.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)
@@ -848,6 +1787,22 @@ func (x *DevicePvcallsif) fromC(xc *C.libxl_device_pvcallsif) error {
return nil
}
+func (x *DevicePvcallsif) toC(xc *C.libxl_device_pvcallsif) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_pvcallsif_dispose(xc)
+ }
+ }()
+
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+ xc.devid = C.libxl_devid(x.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)
@@ -878,6 +1833,25 @@ func (x *DeviceChannelConnectionUnionSocket) fromC(xc *C.libxl_device_channel) e
return nil
}
+func (x *DeviceChannel) toC(xc *C.libxl_device_channel) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_channel_dispose(xc)
+ }
+ }()
+
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+ xc.devid = C.libxl_devid(x.Devid)
+ if x.Name != "" {
+ xc.name = C.CString(x.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)
@@ -886,6 +1860,22 @@ func (x *ConnectorParam) fromC(xc *C.libxl_connector_param) error {
return nil
}
+func (x *ConnectorParam) toC(xc *C.libxl_connector_param) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_connector_param_dispose(xc)
+ }
+ }()
+
+ if x.UniqueId != "" {
+ xc.unique_id = C.CString(x.UniqueId)
+ }
+ xc.width = C.uint32_t(x.Width)
+ xc.height = C.uint32_t(x.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)
@@ -903,6 +1893,23 @@ func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdispl) error {
return nil
}
+func (x *DeviceVdispl) toC(xc *C.libxl_device_vdispl) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_vdispl_dispose(xc)
+ }
+ }()
+
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+ xc.devid = C.libxl_devid(x.Devid)
+ xc.be_alloc = C.bool(x.BeAlloc)
+
+ 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]
@@ -923,6 +1930,20 @@ func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error {
return nil
}
+func (x *VsndParams) toC(xc *C.libxl_vsnd_params) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vsnd_params_dispose(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 nil
+}
+
func (x *VsndStream) fromC(xc *C.libxl_vsnd_stream) error {
x.UniqueId = C.GoString(xc.unique_id)
x.Type = VsndStreamType(xc._type)
@@ -933,6 +1954,24 @@ func (x *VsndStream) fromC(xc *C.libxl_vsnd_stream) error {
return nil
}
+func (x *VsndStream) toC(xc *C.libxl_vsnd_stream) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vsnd_stream_dispose(xc)
+ }
+ }()
+
+ if x.UniqueId != "" {
+ xc.unique_id = C.CString(x.UniqueId)
+ }
+ xc._type = C.libxl_vsnd_stream_type(x.Type)
+ if err := x.Params.toC(&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 {
@@ -950,6 +1989,23 @@ func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error {
return nil
}
+func (x *VsndPcm) toC(xc *C.libxl_vsnd_pcm) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vsnd_pcm_dispose(xc)
+ }
+ }()
+
+ if x.Name != "" {
+ xc.name = C.CString(x.Name)
+ }
+ if err := x.Params.toC(&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)
@@ -971,6 +2027,31 @@ func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error {
return nil
}
+func (x *DeviceVsnd) toC(xc *C.libxl_device_vsnd) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_device_vsnd_dispose(xc)
+ }
+ }()
+
+ xc.backend_domid = C.libxl_domid(x.BackendDomid)
+ if x.BackendDomname != "" {
+ xc.backend_domname = C.CString(x.BackendDomname)
+ }
+ xc.devid = C.libxl_devid(x.Devid)
+ if x.ShortName != "" {
+ xc.short_name = C.CString(x.ShortName)
+ }
+ if x.LongName != "" {
+ xc.long_name = C.CString(x.LongName)
+ }
+ if err := x.Params.toC(&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
@@ -1107,6 +2188,28 @@ func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error {
return nil
}
+func (x *DomainConfig) toC(xc *C.libxl_domain_config) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_domain_config_dispose(xc)
+ }
+ }()
+
+ if err := x.CInfo.toC(&xc.c_info); err != nil {
+ return err
+ }
+ if err := x.BInfo.toC(&xc.b_info); err != nil {
+ return 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 nil
+}
+
func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1120,6 +2223,29 @@ func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error {
return nil
}
+func (x *Diskinfo) toC(xc *C.libxl_diskinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_diskinfo_dispose(xc)
+ }
+ }()
+
+ if x.Backend != "" {
+ xc.backend = C.CString(x.Backend)
+ }
+ xc.backend_id = C.uint32_t(x.BackendId)
+ if x.Frontend != "" {
+ 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 nil
+}
+
func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1134,6 +2260,30 @@ func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error {
return nil
}
+func (x *Nicinfo) toC(xc *C.libxl_nicinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_nicinfo_dispose(xc)
+ }
+ }()
+
+ if x.Backend != "" {
+ xc.backend = C.CString(x.Backend)
+ }
+ xc.backend_id = C.uint32_t(x.BackendId)
+ if x.Frontend != "" {
+ 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 nil
+}
+
func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1150,6 +2300,32 @@ func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error {
return nil
}
+func (x *Vtpminfo) toC(xc *C.libxl_vtpminfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vtpminfo_dispose(xc)
+ }
+ }()
+
+ if x.Backend != "" {
+ xc.backend = C.CString(x.Backend)
+ }
+ xc.backend_id = C.uint32_t(x.BackendId)
+ if x.Frontend != "" {
+ 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)
+ if err := x.Uuid.toC(&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)
@@ -1167,6 +2343,33 @@ func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo) error {
return nil
}
+func (x *Usbctrlinfo) toC(xc *C.libxl_usbctrlinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_usbctrlinfo_dispose(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)
+ if x.Backend != "" {
+ xc.backend = C.CString(x.Backend)
+ }
+ xc.backend_id = C.uint32_t(x.BackendId)
+ if x.Frontend != "" {
+ 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 nil
+}
+
func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error {
x.Vcpuid = uint32(xc.vcpuid)
x.Cpu = uint32(xc.cpu)
@@ -1184,6 +2387,29 @@ func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error {
return nil
}
+func (x *Vcpuinfo) toC(xc *C.libxl_vcpuinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vcpuinfo_dispose(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)
+ if err := x.Cpumap.toC(&xc.cpumap); err != nil {
+ return err
+ }
+ if err := x.CpumapSoft.toC(&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)
@@ -1211,6 +2437,39 @@ func (x *Physinfo) fromC(xc *C.libxl_physinfo) error {
return nil
}
+func (x *Physinfo) toC(xc *C.libxl_physinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_physinfo_dispose(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)
+ if err := x.HwCap.toC(&xc.hw_cap); err != nil {
+ return 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 nil
+}
+
func (x *Connectorinfo) fromC(xc *C.libxl_connectorinfo) error {
x.UniqueId = C.GoString(xc.unique_id)
x.Width = uint32(xc.width)
@@ -1223,6 +2482,26 @@ func (x *Connectorinfo) fromC(xc *C.libxl_connectorinfo) error {
return nil
}
+func (x *Connectorinfo) toC(xc *C.libxl_connectorinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_connectorinfo_dispose(xc)
+ }
+ }()
+
+ if x.UniqueId != "" {
+ 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 nil
+}
+
func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1243,6 +2522,28 @@ func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error {
return nil
}
+func (x *Vdisplinfo) toC(xc *C.libxl_vdisplinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vdisplinfo_dispose(xc)
+ }
+ }()
+
+ if x.Backend != "" {
+ xc.backend = C.CString(x.Backend)
+ }
+ xc.backend_id = C.uint32_t(x.BackendId)
+ if x.Frontend != "" {
+ 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 nil
+}
+
func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error {
x.ReqEvtch = int(xc.req_evtch)
x.ReqRref = int(xc.req_rref)
@@ -1250,6 +2551,19 @@ func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error {
return nil
}
+func (x *Streaminfo) toC(xc *C.libxl_streaminfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_streaminfo_dispose(xc)
+ }
+ }()
+
+ xc.req_evtch = C.int(x.ReqEvtch)
+ xc.req_rref = C.int(x.ReqRref)
+
+ return 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]
@@ -1263,6 +2577,16 @@ func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error {
return nil
}
+func (x *Pcminfo) toC(xc *C.libxl_pcminfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_pcminfo_dispose(xc)
+ }
+ }()
+
+ return nil
+}
+
func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1282,6 +2606,27 @@ func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error {
return nil
}
+func (x *Vsndinfo) toC(xc *C.libxl_vsndinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vsndinfo_dispose(xc)
+ }
+ }()
+
+ if x.Backend != "" {
+ xc.backend = C.CString(x.Backend)
+ }
+ xc.backend_id = C.uint32_t(x.BackendId)
+ if x.Frontend != "" {
+ 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 nil
+}
+
func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error {
x.Backend = C.GoString(xc.backend)
x.BackendId = uint32(xc.backend_id)
@@ -1295,6 +2640,29 @@ func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error {
return nil
}
+func (x *Vkbinfo) toC(xc *C.libxl_vkbinfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_vkbinfo_dispose(xc)
+ }
+ }()
+
+ if x.Backend != "" {
+ xc.backend = C.CString(x.Backend)
+ }
+ xc.backend_id = C.uint32_t(x.BackendId)
+ if x.Frontend != "" {
+ 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 nil
+}
+
func (x *Numainfo) fromC(xc *C.libxl_numainfo) error {
x.Size = uint64(xc.size)
x.Free = uint64(xc.free)
@@ -1308,6 +2676,19 @@ func (x *Numainfo) fromC(xc *C.libxl_numainfo) error {
return nil
}
+func (x *Numainfo) toC(xc *C.libxl_numainfo) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_numainfo_dispose(xc)
+ }
+ }()
+
+ xc.size = C.uint64_t(x.Size)
+ xc.free = C.uint64_t(x.Free)
+
+ return nil
+}
+
func (x *Cputopology) fromC(xc *C.libxl_cputopology) error {
x.Core = uint32(xc.core)
x.Socket = uint32(xc.socket)
@@ -1316,6 +2697,20 @@ func (x *Cputopology) fromC(xc *C.libxl_cputopology) error {
return nil
}
+func (x *Cputopology) toC(xc *C.libxl_cputopology) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_cputopology_dispose(xc)
+ }
+ }()
+
+ xc.core = C.uint32_t(x.Core)
+ xc.socket = C.uint32_t(x.Socket)
+ xc.node = C.uint32_t(x.Node)
+
+ return nil
+}
+
func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error {
x.Seg = uint16(xc.seg)
x.Bus = byte(xc.bus)
@@ -1325,6 +2720,21 @@ func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error {
return nil
}
+func (x *Pcitopology) toC(xc *C.libxl_pcitopology) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_pcitopology_dispose(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 nil
+}
+
func (x *SchedCreditParams) fromC(xc *C.libxl_sched_credit_params) error {
x.TsliceMs = int(xc.tslice_ms)
x.RatelimitUs = int(xc.ratelimit_us)
@@ -1333,12 +2743,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) {
+ xc.tslice_ms = C.int(x.TsliceMs)
+ xc.ratelimit_us = C.int(x.RatelimitUs)
+ xc.vcpu_migr_delay_us = C.int(x.VcpuMigrDelayUs)
+
+ return 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) {
+ xc.ratelimit_us = C.int(x.RatelimitUs)
+
+ 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 {
@@ -1367,6 +2791,42 @@ 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) {
+ defer func() {
+ if err != nil {
+ C.libxl_domain_remus_info_dispose(xc)
+ }
+ }()
+
+ xc.interval = C.int(x.Interval)
+ if err := x.AllowUnsafe.toC(&xc.allow_unsafe); err != nil {
+ return err
+ }
+ if err := x.Blackhole.toC(&xc.blackhole); err != nil {
+ return err
+ }
+ if err := x.Compression.toC(&xc.compression); err != nil {
+ return err
+ }
+ if err := x.Netbuf.toC(&xc.netbuf); err != nil {
+ return err
+ }
+ if x.Netbufscript != "" {
+ xc.netbufscript = C.CString(x.Netbufscript)
+ }
+ if err := x.Diskbuf.toC(&xc.diskbuf); err != nil {
+ return err
+ }
+ if err := x.Colo.toC(&xc.colo); err != nil {
+ return err
+ }
+ if err := x.UserspaceColoProxy.toC(&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
@@ -1436,6 +2896,25 @@ func (x *EventTypeUnionOperationComplete) fromC(xc *C.libxl_event) error {
return nil
}
+func (x *Event) toC(xc *C.libxl_event) (err error) {
+ defer func() {
+ if err != nil {
+ C.libxl_event_dispose(xc)
+ }
+ }()
+
+ if err := x.Link.toC(&xc.link); err != nil {
+ return err
+ }
+ xc.domid = C.libxl_domid(x.Domid)
+ if err := x.Domuuid.toC(&xc.domuuid); err != nil {
+ return err
+ }
+ xc.for_user = C.uint64_t(x.ForUser)
+
+ return nil
+}
+
func (x *PsrCatInfo) fromC(xc *C.libxl_psr_cat_info) error {
x.Id = uint32(xc.id)
x.CosMax = uint32(xc.cos_max)
@@ -1445,6 +2924,21 @@ 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) {
+ defer func() {
+ if err != nil {
+ C.libxl_psr_cat_info_dispose(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 nil
+}
+
func (x *PsrHwInfo) fromC(xc *C.libxl_psr_hw_info) error {
x.Id = uint32(xc.id)
x.Type = PsrFeatType(xc._type)
@@ -1491,3 +2985,15 @@ 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) {
+ defer func() {
+ if err != nil {
+ C.libxl_psr_hw_info_dispose(xc)
+ }
+ }()
+
+ xc.id = C.uint32_t(x.Id)
+
+ return nil
+}
diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go
index 237f26bce9..24b1e022ff 100644
--- a/tools/golang/xenlight/xenlight.go
+++ b/tools/golang/xenlight/xenlight.go
@@ -140,14 +140,12 @@ func (u *Uuid) fromC(c *C.libxl_uuid) error {
return nil
}
-func (u *Uuid) toC() (C.libxl_uuid, error) {
- var c C.libxl_uuid
-
+func (u *Uuid) toC(cu *C.libxl_uuid) error {
for i, v := range u {
- c.uuid[i] = C.uint8_t(v)
+ cu.uuid[i] = C.uint8_t(v)
}
- return c, nil
+ return nil
}
// defboolVal represents a defbool value.
@@ -232,15 +230,13 @@ func (d *Defbool) fromC(c *C.libxl_defbool) error {
return nil
}
-func (d *Defbool) toC() (C.libxl_defbool, error) {
- var c C.libxl_defbool
-
+func (d *Defbool) toC(cd *C.libxl_defbool) error {
if !d.IsDefault() {
val, _ := d.Val()
- C.libxl_defbool_set(&c, C.bool(val))
+ C.libxl_defbool_set(cd, C.bool(val))
}
- return c, nil
+ return nil
}
// Mac represents a libxl_mac, or simply a MAC address.
@@ -266,14 +262,12 @@ func (mac *Mac) fromC(cmac *C.libxl_mac) error {
return nil
}
-func (mac Mac) toC() (C.libxl_mac, error) {
- var cmac C.libxl_mac
-
+func (mac Mac) toC(cm *C.libxl_mac) error {
for i, v := range mac {
- cmac[i] = C.uint8_t(v)
+ (*cm)[i] = C.uint8_t(v)
}
- return cmac, nil
+ return nil
}
// MsVmGenid represents a libxl_ms_vm_genid.
@@ -287,14 +281,12 @@ func (mvg *MsVmGenid) fromC(cmvg *C.libxl_ms_vm_genid) error {
return nil
}
-func (mvg *MsVmGenid) toC() (C.libxl_ms_vm_genid, error) {
- var cmvg C.libxl_ms_vm_genid
-
+func (mvg *MsVmGenid) toC(cmvg *C.libxl_ms_vm_genid) error {
for i, v := range mvg {
cmvg.bytes[i] = C.uint8_t(v)
}
- return cmvg, nil
+ return nil
}
// EvLink represents a libxl_ev_link.
@@ -304,8 +296,8 @@ func (mvg *MsVmGenid) toC() (C.libxl_ms_vm_genid, error) {
// 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 }
+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.
//
@@ -316,20 +308,18 @@ 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
-
+func (cpl CpuidPolicyList) toC(ccpl *C.libxl_cpuid_policy_list) error {
s := C.CString(string(cpl))
defer C.free(unsafe.Pointer(s))
- ret := C.libxl_cpuid_parse_config(&ccpl, s)
+ ret := C.libxl_cpuid_parse_config(ccpl, s)
if ret != 0 {
- C.libxl_cpuid_dispose(&ccpl)
+ C.libxl_cpuid_dispose(ccpl)
- return ccpl, Error(-ret)
+ return Error(-ret)
}
- return ccpl, nil
+ return nil
}
// Hwcap represents a libxl_hwcap.
@@ -343,14 +333,12 @@ func (hwcap *Hwcap) fromC(chwcap *C.libxl_hwcap) error {
return nil
}
-func (hwcap *Hwcap) toC() (C.libxl_hwcap, error) {
- var chwcap C.libxl_hwcap
-
+func (hwcap *Hwcap) toC(chwcap *C.libxl_hwcap) error {
for i, v := range hwcap {
- chwcap[i] = C.uint32_t(v)
+ (*chwcap)[i] = C.uint32_t(v)
}
- return chwcap, nil
+ return nil
}
// KeyValueList represents a libxl_key_value_list.
@@ -360,8 +348,8 @@ func (hwcap *Hwcap) toC() (C.libxl_hwcap, error) {
// 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 }
+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
@@ -379,17 +367,17 @@ func (sl *StringList) fromC(csl *C.libxl_string_list) error {
return nil
}
-func (sl StringList) toC() (C.libxl_string_list, error) {
+func (sl StringList) toC(csl *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))))
+ *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
+ return nil
}
// Bitmap represents a libxl_bitmap.
@@ -421,9 +409,7 @@ func (bm *Bitmap) fromC(cbm *C.libxl_bitmap) error {
return nil
}
-func (bm *Bitmap) toC() (C.libxl_bitmap, error) {
- var cbm C.libxl_bitmap
-
+func (bm *Bitmap) toC(cbm *C.libxl_bitmap) error {
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))
@@ -431,7 +417,7 @@ func (bm *Bitmap) toC() (C.libxl_bitmap, error) {
copy(cs, bm.bitmap)
- return cbm, nil
+ return nil
}
func (sr ShutdownReason) String() (str string) {
@@ -534,8 +520,8 @@ func (Ctx *Context) CpupoolCreate(Name string, Scheduler Scheduler, Cpumap Bitma
var uuid C.libxl_uuid
C.libxl_uuid_generate(&uuid)
- cbm, err := Cpumap.toC()
- if err != nil {
+ var cbm C.libxl_bitmap
+ if err = Cpumap.toC(&cbm); err != nil {
return
}
defer C.libxl_bitmap_dispose(&cbm)
@@ -577,8 +563,8 @@ 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) {
- cbm, err := Cpumap.toC()
- if err != nil {
+ var cbm C.libxl_bitmap
+ if err = Cpumap.toC(&cbm); err != nil {
return
}
defer C.libxl_bitmap_dispose(&cbm)
@@ -606,8 +592,8 @@ 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) {
- cbm, err := Cpumap.toC()
- if err != nil {
+ var cbm C.libxl_bitmap
+ if err = Cpumap.toC(&cbm); err != nil {
return
}
defer C.libxl_bitmap_dispose(&cbm)
--
2.17.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [Xen-devel] [PATCH v5 2/3] golang/xenlight: implement keyed union Go to C marshaling
2020-01-04 21:00 [Xen-devel] [PATCH v5 0/3] generated Go libxl bindings using IDL Nick Rosbrook
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 1/3] golang/xenlight: begin Go to C type marshaling Nick Rosbrook
@ 2020-01-04 21:00 ` Nick Rosbrook
2020-01-16 16:16 ` George Dunlap
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 3/3] golang/xenlight: implement array " Nick Rosbrook
2 siblings, 1 reply; 9+ messages in thread
From: Nick Rosbrook @ 2020-01-04 21:00 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, George Dunlap, Wei Liu
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>
---
Changes in v5:
- Make use of xenlight_golang_convert_to_C to convert fields.
- Remove dispose_fn from parameter list in xenlight_golang_union_to_C
since it's no longer needed.
---
tools/golang/xenlight/gengotypes.py | 79 ++++++-
tools/golang/xenlight/helpers.gen.go | 294 +++++++++++++++++++++++++++
2 files changed, 366 insertions(+), 7 deletions(-)
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
index 15aa4be220..8ab6768e61 100644
--- a/tools/golang/xenlight/gengotypes.py
+++ b/tools/golang/xenlight/gengotypes.py
@@ -464,15 +464,15 @@ def xenlight_golang_define_to_C(ty = None, typename = None, nested = False):
body += xenlight_golang_convert_to_C(nf, outer_name=f.name)
elif isinstance(f.type, idl.KeyedUnion):
- # TODO
- pass
+ body += xenlight_golang_union_to_C(f.type, f.name, ty.typename)
else:
raise Exception('type {} not supported'.format(f.type))
return func.format(goname, cname, body)
-def xenlight_golang_convert_to_C(ty = None, outer_name = None):
+def xenlight_golang_convert_to_C(ty = None, outer_name = None,
+ govarname = None, cvarname = None):
"""
Returns a line of Go code that converts the Go type represented
by ty to its corresponding Go type.
@@ -482,6 +482,14 @@ def xenlight_golang_convert_to_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'
+
+ # Use 'x' as the name for the Go variable unless otherwise specified.
+ if govarname is None:
+ govarname = 'x'
+
gotypename = xenlight_golang_fmt_name(ty.type.typename)
ctypename = ty.type.typename
goname = xenlight_golang_fmt_name(ty.name)
@@ -502,16 +510,73 @@ def xenlight_golang_convert_to_C(ty = None, outer_name = None):
gotypename in go_builtin_types)
if not is_castable:
- s += 'if err := x.{}.toC(&xc.{}); err != nil {{\n'.format(goname,cname)
+ s += 'if err := {}.{}.toC(&{}.{}); err != nil {{\n'.format(govarname,goname,
+ cvarname,cname)
s += 'return err\n}\n'
elif gotypename == 'string':
# Use the cgo helper for converting C strings.
- s += 'if x.{} != "" {{\n'.format(goname)
- s += 'xc.{} = C.CString(x.{})}}\n'.format(cname,goname)
+ s += 'if {}.{} != "" {{\n'.format(govarname,goname)
+ s += '{}.{} = C.CString({}.{})}}\n'.format(cvarname,cname,
+ govarname,goname)
else:
- s += 'xc.{} = C.{}(x.{})\n'.format(cname,ctypename,goname)
+ s += '{}.{} = C.{}({}.{})\n'.format(cvarname,cname,ctypename,
+ govarname,goname)
+
+ return s
+
+def xenlight_golang_union_to_C(ty = None, union_name = '',
+ struct_name = ''):
+ 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)
+
+ field_name = xenlight_golang_fmt_name('{}_union'.format(keyname))
+ s += 'tmp, ok := x.{}.({})\n'.format(field_name,gotype)
+ s += 'if !ok {\n'
+ s += 'return 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:
+ s += xenlight_golang_convert_to_C(uf,cvarname=f.name,
+ govarname='tmp')
+
+ # 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 fmt.Errorf({})'.format(err_string)
+ s += '}\n'
return s
diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go
index 30cd1a9b3f..0bf2b0ddef 100644
--- a/tools/golang/xenlight/helpers.gen.go
+++ b/tools/golang/xenlight/helpers.gen.go
@@ -381,6 +381,22 @@ 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 {
+ return errors.New("wrong type for union key connection")
+ }
+ var pty C.libxl_channelinfo_connection_union_pty
+ if tmp.Path != "" {
+ 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 fmt.Errorf("invalid union key '%v'", x.Connection)
+ }
return nil
}
@@ -1124,6 +1140,189 @@ func (x *DomainBuildInfo) toC(xc *C.libxl_domain_build_info) (err error) {
return 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 {
+ return errors.New("wrong type for union key type")
+ }
+ var hvm C.libxl_domain_build_info_type_union_hvm
+ if tmp.Firmware != "" {
+ hvm.firmware = C.CString(tmp.Firmware)
+ }
+ hvm.bios = C.libxl_bios_type(tmp.Bios)
+ if err := tmp.Pae.toC(&hvm.pae); err != nil {
+ return err
+ }
+ if err := tmp.Apic.toC(&hvm.apic); err != nil {
+ return err
+ }
+ if err := tmp.Acpi.toC(&hvm.acpi); err != nil {
+ return err
+ }
+ if err := tmp.AcpiS3.toC(&hvm.acpi_s3); err != nil {
+ return err
+ }
+ if err := tmp.AcpiS4.toC(&hvm.acpi_s4); err != nil {
+ return err
+ }
+ if err := tmp.AcpiLaptopSlate.toC(&hvm.acpi_laptop_slate); err != nil {
+ return err
+ }
+ if err := tmp.Nx.toC(&hvm.nx); err != nil {
+ return err
+ }
+ if err := tmp.Viridian.toC(&hvm.viridian); err != nil {
+ return err
+ }
+ if err := tmp.ViridianEnable.toC(&hvm.viridian_enable); err != nil {
+ return err
+ }
+ if err := tmp.ViridianDisable.toC(&hvm.viridian_disable); err != nil {
+ return err
+ }
+ if tmp.Timeoffset != "" {
+ hvm.timeoffset = C.CString(tmp.Timeoffset)
+ }
+ if err := tmp.Hpet.toC(&hvm.hpet); err != nil {
+ return err
+ }
+ if err := tmp.VptAlign.toC(&hvm.vpt_align); err != nil {
+ return err
+ }
+ hvm.mmio_hole_memkb = C.uint64_t(tmp.MmioHoleMemkb)
+ hvm.timer_mode = C.libxl_timer_mode(tmp.TimerMode)
+ if err := tmp.NestedHvm.toC(&hvm.nested_hvm); err != nil {
+ return err
+ }
+ if err := tmp.Altp2M.toC(&hvm.altp2m); err != nil {
+ return err
+ }
+ if tmp.SystemFirmware != "" {
+ hvm.system_firmware = C.CString(tmp.SystemFirmware)
+ }
+ if tmp.SmbiosFirmware != "" {
+ hvm.smbios_firmware = C.CString(tmp.SmbiosFirmware)
+ }
+ if tmp.AcpiFirmware != "" {
+ hvm.acpi_firmware = C.CString(tmp.AcpiFirmware)
+ }
+ hvm.hdtype = C.libxl_hdtype(tmp.Hdtype)
+ if err := tmp.Nographic.toC(&hvm.nographic); err != nil {
+ return err
+ }
+ if err := tmp.Vga.toC(&hvm.vga); err != nil {
+ return err
+ }
+ if err := tmp.Vnc.toC(&hvm.vnc); err != nil {
+ return err
+ }
+ if tmp.Keymap != "" {
+ hvm.keymap = C.CString(tmp.Keymap)
+ }
+ if err := tmp.Sdl.toC(&hvm.sdl); err != nil {
+ return err
+ }
+ if err := tmp.Spice.toC(&hvm.spice); err != nil {
+ return err
+ }
+ if err := tmp.GfxPassthru.toC(&hvm.gfx_passthru); err != nil {
+ return err
+ }
+ hvm.gfx_passthru_kind = C.libxl_gfx_passthru_kind(tmp.GfxPassthruKind)
+ if tmp.Serial != "" {
+ hvm.serial = C.CString(tmp.Serial)
+ }
+ if tmp.Boot != "" {
+ hvm.boot = C.CString(tmp.Boot)
+ }
+ if err := tmp.Usb.toC(&hvm.usb); err != nil {
+ return err
+ }
+ hvm.usbversion = C.int(tmp.Usbversion)
+ if tmp.Usbdevice != "" {
+ hvm.usbdevice = C.CString(tmp.Usbdevice)
+ }
+ if err := tmp.VkbDevice.toC(&hvm.vkb_device); err != nil {
+ return err
+ }
+ if tmp.Soundhw != "" {
+ hvm.soundhw = C.CString(tmp.Soundhw)
+ }
+ if err := tmp.XenPlatformPci.toC(&hvm.xen_platform_pci); err != nil {
+ return err
+ }
+ if err := tmp.UsbdeviceList.toC(&hvm.usbdevice_list); err != nil {
+ return err
+ }
+ hvm.vendor_device = C.libxl_vendor_device(tmp.VendorDevice)
+ if err := tmp.MsVmGenid.toC(&hvm.ms_vm_genid); err != nil {
+ return err
+ }
+ if err := tmp.SerialList.toC(&hvm.serial_list); err != nil {
+ return err
+ }
+ if err := tmp.Rdm.toC(&hvm.rdm); err != nil {
+ return 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 {
+ return errors.New("wrong type for union key type")
+ }
+ var pv C.libxl_domain_build_info_type_union_pv
+ if tmp.Kernel != "" {
+ pv.kernel = C.CString(tmp.Kernel)
+ }
+ pv.slack_memkb = C.uint64_t(tmp.SlackMemkb)
+ if tmp.Bootloader != "" {
+ pv.bootloader = C.CString(tmp.Bootloader)
+ }
+ if err := tmp.BootloaderArgs.toC(&pv.bootloader_args); err != nil {
+ return err
+ }
+ if tmp.Cmdline != "" {
+ pv.cmdline = C.CString(tmp.Cmdline)
+ }
+ if tmp.Ramdisk != "" {
+ pv.ramdisk = C.CString(tmp.Ramdisk)
+ }
+ if tmp.Features != "" {
+ pv.features = C.CString(tmp.Features)
+ }
+ if err := tmp.E820Host.toC(&pv.e820_host); err != nil {
+ return 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 {
+ return errors.New("wrong type for union key type")
+ }
+ var pvh C.libxl_domain_build_info_type_union_pvh
+ if err := tmp.Pvshim.toC(&pvh.pvshim); err != nil {
+ return err
+ }
+ if tmp.PvshimPath != "" {
+ pvh.pvshim_path = C.CString(tmp.PvshimPath)
+ }
+ if tmp.PvshimCmdline != "" {
+ pvh.pvshim_cmdline = C.CString(tmp.PvshimCmdline)
+ }
+ if tmp.PvshimExtra != "" {
+ 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 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)
@@ -1689,6 +1888,21 @@ func (x *DeviceUsbdev) toC(xc *C.libxl_device_usbdev) (err error) {
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 {
+ return 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 fmt.Errorf("invalid union key '%v'", x.Type)
+ }
return nil
}
@@ -1848,6 +2062,22 @@ func (x *DeviceChannel) toC(xc *C.libxl_device_channel) (err error) {
if x.Name != "" {
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 {
+ return errors.New("wrong type for union key connection")
+ }
+ var socket C.libxl_device_channel_connection_union_socket
+ if tmp.Path != "" {
+ 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 fmt.Errorf("invalid union key '%v'", x.Connection)
+ }
return nil
}
@@ -2911,6 +3141,43 @@ func (x *Event) toC(xc *C.libxl_event) (err error) {
return 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 {
+ return 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 {
+ return errors.New("wrong type for union key type")
+ }
+ var disk_eject C.libxl_event_type_union_disk_eject
+ if tmp.Vdev != "" {
+ disk_eject.vdev = C.CString(tmp.Vdev)
+ }
+ if err := tmp.Disk.toC(&disk_eject.disk); err != nil {
+ return 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 {
+ return 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 fmt.Errorf("invalid union key '%v'", x.Type)
+ }
return nil
}
@@ -2994,6 +3261,33 @@ func (x *PsrHwInfo) toC(xc *C.libxl_psr_hw_info) (err error) {
}()
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 {
+ return 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 {
+ return 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 fmt.Errorf("invalid union key '%v'", x.Type)
+ }
return nil
}
--
2.17.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [Xen-devel] [PATCH v5 3/3] golang/xenlight: implement array Go to C marshaling
2020-01-04 21:00 [Xen-devel] [PATCH v5 0/3] generated Go libxl bindings using IDL Nick Rosbrook
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 1/3] golang/xenlight: begin Go to C type marshaling Nick Rosbrook
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 2/3] golang/xenlight: implement keyed union Go to C marshaling Nick Rosbrook
@ 2020-01-04 21:00 ` Nick Rosbrook
2020-01-16 16:20 ` George Dunlap
2 siblings, 1 reply; 9+ messages in thread
From: Nick Rosbrook @ 2020-01-04 21:00 UTC (permalink / raw)
To: xen-devel; +Cc: Nick Rosbrook, Ian Jackson, George Dunlap, Wei Liu
Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
---
Changes in v5:
- Remove dispose_fn from parameter list in xenlight_golang_array_to_C
since it's no longer needed.
- Update call to toC for elements of arrays of structs so that it
matches the new function signature of toC.
- Do not try to marshal zero-length arrays.
---
tools/golang/xenlight/gengotypes.py | 41 +++-
tools/golang/xenlight/helpers.gen.go | 311 +++++++++++++++++++++++++++
2 files changed, 351 insertions(+), 1 deletion(-)
diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py
index 8ab6768e61..27edf66241 100644
--- a/tools/golang/xenlight/gengotypes.py
+++ b/tools/golang/xenlight/gengotypes.py
@@ -454,7 +454,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
+ body += xenlight_golang_array_to_C(f)
continue
body += xenlight_golang_convert_to_C(f)
@@ -580,6 +580,45 @@ def xenlight_golang_union_to_C(ty = None, union_name = '',
return s
+def xenlight_golang_array_to_C(ty = None):
+ 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 += 'if {} := len(x.{}); {} > 0 {{\n'.format(golenvar,goname,golenvar)
+ 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}\n'
+
+ return s
+
+ s += 'if {} := len(x.{}); {} > 0 {{\n'.format(golenvar,goname,golenvar)
+ 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 += 'if err := v.toC(&c{}[i]); err != nil {{\n'.format(goname)
+ s += 'return err\n'
+ s += '}\n}\n}\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 0bf2b0ddef..b9a7e828a0 100644
--- a/tools/golang/xenlight/helpers.gen.go
+++ b/tools/golang/xenlight/helpers.gen.go
@@ -643,6 +643,16 @@ func (x *VcpuSchedParams) toC(xc *C.libxl_vcpu_sched_params) (err error) {
}()
xc.sched = C.libxl_scheduler(x.Sched)
+ if numVcpus := len(x.Vcpus); numVcpus > 0 {
+ 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 {
+ if err := v.toC(&cVcpus[i]); err != nil {
+ return err
+ }
+ }
+ }
return nil
}
@@ -703,6 +713,14 @@ func (x *VnodeInfo) toC(xc *C.libxl_vnode_info) (err error) {
}()
xc.memkb = C.uint64_t(x.Memkb)
+ if numDistances := len(x.Distances); numDistances > 0 {
+ 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)
if err := x.Vcpus.toC(&xc.vcpus); err != nil {
return err
@@ -1050,6 +1068,26 @@ func (x *DomainBuildInfo) toC(xc *C.libxl_domain_build_info) (err error) {
if err := x.Nodemap.toC(&xc.nodemap); err != nil {
return err
}
+ if numVcpuHardAffinity := len(x.VcpuHardAffinity); numVcpuHardAffinity > 0 {
+ 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 {
+ if err := v.toC(&cVcpuHardAffinity[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numVcpuSoftAffinity := len(x.VcpuSoftAffinity); numVcpuSoftAffinity > 0 {
+ 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 {
+ if err := v.toC(&cVcpuSoftAffinity[i]); err != nil {
+ return err
+ }
+ }
+ }
if err := x.NumaPlacement.toC(&xc.numa_placement); err != nil {
return err
}
@@ -1076,6 +1114,16 @@ func (x *DomainBuildInfo) toC(xc *C.libxl_domain_build_info) (err error) {
if x.BlkdevStart != "" {
xc.blkdev_start = C.CString(x.BlkdevStart)
}
+ if numVnumaNodes := len(x.VnumaNodes); numVnumaNodes > 0 {
+ 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 {
+ if err := v.toC(&cVnumaNodes[i]); err != nil {
+ return err
+ }
+ }
+ }
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)
@@ -1104,6 +1152,34 @@ func (x *DomainBuildInfo) toC(xc *C.libxl_domain_build_info) (err error) {
if err := x.SchedParams.toC(&xc.sched_params); err != nil {
return err
}
+ if numIoports := len(x.Ioports); numIoports > 0 {
+ 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 {
+ if err := v.toC(&cIoports[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numIrqs := len(x.Irqs); numIrqs > 0 {
+ 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)
+ }
+ }
+ if numIomem := len(x.Iomem); numIomem > 0 {
+ 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 {
+ if err := v.toC(&cIomem[i]); err != nil {
+ return err
+ }
+ }
+ }
if err := x.ClaimMode.toC(&xc.claim_mode); err != nil {
return err
}
@@ -2136,6 +2212,16 @@ func (x *DeviceVdispl) toC(xc *C.libxl_device_vdispl) (err error) {
}
xc.devid = C.libxl_devid(x.Devid)
xc.be_alloc = C.bool(x.BeAlloc)
+ if numConnectors := len(x.Connectors); numConnectors > 0 {
+ 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 {
+ if err := v.toC(&cConnectors[i]); err != nil {
+ return err
+ }
+ }
+ }
return nil
}
@@ -2167,6 +2253,22 @@ func (x *VsndParams) toC(xc *C.libxl_vsnd_params) (err error) {
}
}()
+ if numSampleRates := len(x.SampleRates); numSampleRates > 0 {
+ 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)
+ }
+ }
+ if numSampleFormats := len(x.SampleFormats); numSampleFormats > 0 {
+ 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)
@@ -2232,6 +2334,16 @@ func (x *VsndPcm) toC(xc *C.libxl_vsnd_pcm) (err error) {
if err := x.Params.toC(&xc.params); err != nil {
return err
}
+ if numVsndStreams := len(x.Streams); numVsndStreams > 0 {
+ 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 {
+ if err := v.toC(&cStreams[i]); err != nil {
+ return err
+ }
+ }
+ }
return nil
}
@@ -2278,6 +2390,16 @@ func (x *DeviceVsnd) toC(xc *C.libxl_device_vsnd) (err error) {
if err := x.Params.toC(&xc.params); err != nil {
return err
}
+ if numVsndPcms := len(x.Pcms); numVsndPcms > 0 {
+ 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 {
+ if err := v.toC(&cPcms[i]); err != nil {
+ return err
+ }
+ }
+ }
return nil
}
@@ -2431,6 +2553,156 @@ func (x *DomainConfig) toC(xc *C.libxl_domain_config) (err error) {
if err := x.BInfo.toC(&xc.b_info); err != nil {
return err
}
+ if numDisks := len(x.Disks); numDisks > 0 {
+ 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 {
+ if err := v.toC(&cDisks[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numNics := len(x.Nics); numNics > 0 {
+ 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 {
+ if err := v.toC(&cNics[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numPcidevs := len(x.Pcidevs); numPcidevs > 0 {
+ 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 {
+ if err := v.toC(&cPcidevs[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numRdms := len(x.Rdms); numRdms > 0 {
+ 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 {
+ if err := v.toC(&cRdms[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numDtdevs := len(x.Dtdevs); numDtdevs > 0 {
+ 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 {
+ if err := v.toC(&cDtdevs[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numVfbs := len(x.Vfbs); numVfbs > 0 {
+ 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 {
+ if err := v.toC(&cVfbs[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numVkbs := len(x.Vkbs); numVkbs > 0 {
+ 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 {
+ if err := v.toC(&cVkbs[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numVtpms := len(x.Vtpms); numVtpms > 0 {
+ 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 {
+ if err := v.toC(&cVtpms[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numP9S := len(x.P9S); numP9S > 0 {
+ 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 {
+ if err := v.toC(&cP9S[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numPvcallsifs := len(x.Pvcallsifs); numPvcallsifs > 0 {
+ 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 {
+ if err := v.toC(&cPvcallsifs[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numVdispls := len(x.Vdispls); numVdispls > 0 {
+ 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 {
+ if err := v.toC(&cVdispls[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numVsnds := len(x.Vsnds); numVsnds > 0 {
+ 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 {
+ if err := v.toC(&cVsnds[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numChannels := len(x.Channels); numChannels > 0 {
+ 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 {
+ if err := v.toC(&cChannels[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numUsbctrls := len(x.Usbctrls); numUsbctrls > 0 {
+ 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 {
+ if err := v.toC(&cUsbctrls[i]); err != nil {
+ return err
+ }
+ }
+ }
+ if numUsbdevs := len(x.Usbdevs); numUsbdevs > 0 {
+ 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 {
+ if err := v.toC(&cUsbdevs[i]); err != nil {
+ return 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)
@@ -2770,6 +3042,16 @@ 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)
+ if numConnectors := len(x.Connectors); numConnectors > 0 {
+ 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 {
+ if err := v.toC(&cConnectors[i]); err != nil {
+ return err
+ }
+ }
+ }
return nil
}
@@ -2814,6 +3096,17 @@ func (x *Pcminfo) toC(xc *C.libxl_pcminfo) (err error) {
}
}()
+ if numVsndStreams := len(x.Streams); numVsndStreams > 0 {
+ 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 {
+ if err := v.toC(&cStreams[i]); err != nil {
+ return err
+ }
+ }
+ }
+
return nil
}
@@ -2853,6 +3146,16 @@ 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)
+ if numVsndPcms := len(x.Pcms); numVsndPcms > 0 {
+ 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 {
+ if err := v.toC(&cPcms[i]); err != nil {
+ return err
+ }
+ }
+ }
return nil
}
@@ -2915,6 +3218,14 @@ func (x *Numainfo) toC(xc *C.libxl_numainfo) (err error) {
xc.size = C.uint64_t(x.Size)
xc.free = C.uint64_t(x.Free)
+ if numDists := len(x.Dists); numDists > 0 {
+ 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 nil
}
--
2.17.1
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply related [flat|nested] 9+ messages in thread
* Re: [Xen-devel] [PATCH v5 1/3] golang/xenlight: begin Go to C type marshaling
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 1/3] golang/xenlight: begin Go to C type marshaling Nick Rosbrook
@ 2020-01-16 16:00 ` George Dunlap
2020-01-16 16:50 ` Nick Rosbrook
0 siblings, 1 reply; 9+ messages in thread
From: George Dunlap @ 2020-01-16 16:00 UTC (permalink / raw)
To: Nick Rosbrook, xen-devel; +Cc: Nick Rosbrook, Ian Jackson, Wei Liu
On 1/4/20 9:00 PM, Nick Rosbrook wrote:
> Implement conversions for basic types such as strings and integer
> types in toC functions.
>
> Modify function signatures of toC implementations for builtin
> types to be consistent with the signature of the generated toC
> functions.
>
> Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
> ---
> Changes in v5:
> - Define xenlight_golang_convert_to_C so that field conversion code
> can be easily re-used.
> - Check for err in defer'd func within toC to determine if the dispose
> function needs to be called.
> - Pass a reference to the C type in toC, rather than returning a copy
> of the C variable.
> - Update the existing toC functions for builtin types to be consistent
> with the generated functions.
> - Only call CString if the Go string is non-empty.
Looks good! Only one question:
> + if not is_castable:
> + s += 'if err := x.{}.toC(&xc.{}); err != nil {{\n'.format(goname,cname)
Err should be defined function-wide at this point. Are you using `:=`
on purpose for some reason? Would it make sense to make this `=` instead?
If we want to, I can change that on check-in; so either way:
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] 9+ messages in thread
* Re: [Xen-devel] [PATCH v5 2/3] golang/xenlight: implement keyed union Go to C marshaling
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 2/3] golang/xenlight: implement keyed union Go to C marshaling Nick Rosbrook
@ 2020-01-16 16:16 ` George Dunlap
0 siblings, 0 replies; 9+ messages in thread
From: George Dunlap @ 2020-01-16 16:16 UTC (permalink / raw)
To: Nick Rosbrook, xen-devel; +Cc: Nick Rosbrook, Ian Jackson, Wei Liu
On 1/4/20 9:00 PM, Nick Rosbrook wrote:
> 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>
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] 9+ messages in thread
* Re: [Xen-devel] [PATCH v5 3/3] golang/xenlight: implement array Go to C marshaling
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 3/3] golang/xenlight: implement array " Nick Rosbrook
@ 2020-01-16 16:20 ` George Dunlap
0 siblings, 0 replies; 9+ messages in thread
From: George Dunlap @ 2020-01-16 16:20 UTC (permalink / raw)
To: Nick Rosbrook, xen-devel; +Cc: Nick Rosbrook, Ian Jackson, Wei Liu
On 1/4/20 9:00 PM, Nick Rosbrook wrote:
> Signed-off-by: Nick Rosbrook <rosbrookn@ainfosec.com>
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] 9+ messages in thread
* Re: [Xen-devel] [PATCH v5 1/3] golang/xenlight: begin Go to C type marshaling
2020-01-16 16:00 ` George Dunlap
@ 2020-01-16 16:50 ` Nick Rosbrook
2020-01-16 16:56 ` George Dunlap
0 siblings, 1 reply; 9+ messages in thread
From: Nick Rosbrook @ 2020-01-16 16:50 UTC (permalink / raw)
To: George Dunlap; +Cc: Nick Rosbrook, Xen-devel, Ian Jackson, Wei Liu
> Looks good! Only one question:
>
> > + if not is_castable:
> > + s += 'if err := x.{}.toC(&xc.{}); err != nil {{\n'.format(goname,cname)
>
> Err should be defined function-wide at this point. Are you using `:=`
> on purpose for some reason? Would it make sense to make this `=` instead?
This is on purpose. IMO it's better to keep the variable scoped to the
if block when using short statement if syntax. If the desire is to
assign to the same `err` variable, then I would not use the short
statement. Reason being I think it helps readability; the short
statement syntax is handy, but it is easy to glance over and not
realize an assignment is being made.
Thanks,
-NR
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [Xen-devel] [PATCH v5 1/3] golang/xenlight: begin Go to C type marshaling
2020-01-16 16:50 ` Nick Rosbrook
@ 2020-01-16 16:56 ` George Dunlap
0 siblings, 0 replies; 9+ messages in thread
From: George Dunlap @ 2020-01-16 16:56 UTC (permalink / raw)
To: Nick Rosbrook; +Cc: Nick Rosbrook, Xen-devel, Ian Jackson, Wei Liu
On 1/16/20 4:50 PM, Nick Rosbrook wrote:
>> Looks good! Only one question:
>>
>>> + if not is_castable:
>>> + s += 'if err := x.{}.toC(&xc.{}); err != nil {{\n'.format(goname,cname)
>>
>> Err should be defined function-wide at this point. Are you using `:=`
>> on purpose for some reason? Would it make sense to make this `=` instead?
>
> This is on purpose. IMO it's better to keep the variable scoped to the
> if block when using short statement if syntax. If the desire is to
> assign to the same `err` variable, then I would not use the short
> statement. Reason being I think it helps readability; the short
> statement syntax is handy, but it is easy to glance over and not
> realize an assignment is being made.
Fair enough. I'll check this series in once I get a chance to test it
again.
-George
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2020-01-16 16:56 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-01-04 21:00 [Xen-devel] [PATCH v5 0/3] generated Go libxl bindings using IDL Nick Rosbrook
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 1/3] golang/xenlight: begin Go to C type marshaling Nick Rosbrook
2020-01-16 16:00 ` George Dunlap
2020-01-16 16:50 ` Nick Rosbrook
2020-01-16 16:56 ` George Dunlap
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 2/3] golang/xenlight: implement keyed union Go to C marshaling Nick Rosbrook
2020-01-16 16:16 ` George Dunlap
2020-01-04 21:00 ` [Xen-devel] [PATCH v5 3/3] golang/xenlight: implement array " Nick Rosbrook
2020-01-16 16:20 ` George Dunlap
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).