From patchwork Tue Dec 10 15:47:30 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nick Rosbrook X-Patchwork-Id: 11282893 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 052EC14BD for ; Tue, 10 Dec 2019 15:50:26 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id BF4D52077B for ; Tue, 10 Dec 2019 15:50:25 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Sd4MjQio" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BF4D52077B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iehl4-0003bi-CC; Tue, 10 Dec 2019 15:49:06 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iehl3-0003b4-TM for xen-devel@lists.xenproject.org; Tue, 10 Dec 2019 15:49:05 +0000 X-Inumbo-ID: 76eb48f8-1b64-11ea-b6f1-bc764e2007e4 Received: from mail-qt1-x834.google.com (unknown [2607:f8b0:4864:20::834]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 76eb48f8-1b64-11ea-b6f1-bc764e2007e4; Tue, 10 Dec 2019 15:48:09 +0000 (UTC) Received: by mail-qt1-x834.google.com with SMTP id 38so3131172qtb.13 for ; Tue, 10 Dec 2019 07:48:09 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=IKxnF64WqOtC2gu9kOieP6MMS1r7pR3op50iaDflv5Q=; b=Sd4MjQiozvV4+2KgB1L1BR501ktZauaE0xOZNJRmwgmYFW9hilqPReAxtKj9rB6akb 6utXZ0My7hAwSz7ekmyMEp/hdNJxsUGSYAsQ/PGhVs0R6Yl2VpsjXvNTSzUXJ7/+q72o G2kJLK0uyaz6mtNFJC6tHF2cfdiZBHGrUXX5HB/JIQzLNLJ771f7CcR9D8+PbhoXE4Sj w77mf7gTw1Tp0QVs5zcZzKKabJe/dLHdMuEKcgtCcmljpXsTHzGC++ubCpGwSXpdbhYJ HEmIlEbiiOL0PbUkE6+XHPeJzP4whU0YLCzgCTbQUVNKz17aAUrIYSb5FgZEo2Cj5MZU 4Dhw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=IKxnF64WqOtC2gu9kOieP6MMS1r7pR3op50iaDflv5Q=; b=sKUNyEiGvZV99a+IJx3LxfgcWQrrouOCJalV9pHxb7cwGQoytTvW5THpemGqdrVEO4 jA9T6AlKmOWIkBfPneM4KzAqY0Ntj7P2xWeLvMIBJIYOtnocmTfs6NYmS9Av8/wDQ+oR ODDF9Vi7WDyyo1TrCp0KiSUKVaWQ+VwUtj9Ver94A9HZPbsbTSx/I9ELJvKzJ+MFmHRZ lF8zmnq1zdKdccltTkGXLQYWIb+9U5yvvYfCufbCsoqOlZuDVjNbfu3gZDbeTH+FERxa iUvmQMj7NS/Og2tv/fupszjxwXdimT+J0exqyuMVUdS0WAZw+SJgGkvCkVIfbxs5zafb MF5A== X-Gm-Message-State: APjAAAXsIViAnrIKgN3oib9SP2hLuygwbnCYrTQgGF2ejFekVPJS0j7a A0HSKiqfDeRhAhlcZay0EOj70a4c X-Google-Smtp-Source: APXvYqzcKxw3ICT7f6AE6J7dTOUhQlrQl4h3mF85T9AEpcdvnE1KkHDZqCqi5pQ7twlNRqkwgM1kYQ== X-Received: by 2002:ac8:36f5:: with SMTP id b50mr31179907qtc.268.1575992887871; Tue, 10 Dec 2019 07:48:07 -0800 (PST) Received: from five.crux.rad.ainfosec.com (209-217-208-226.northland.net. [209.217.208.226]) by smtp.googlemail.com with ESMTPSA id m29sm1247848qtf.1.2019.12.10.07.48.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 10 Dec 2019 07:48:07 -0800 (PST) From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Tue, 10 Dec 2019 10:47:30 -0500 Message-Id: <3c638e0022455d8c670af7aa0ad5c98305c91221.1575990937.git.rosbrookn@ainfosec.com> X-Mailer: git-send-email 2.19.1 In-Reply-To: References: MIME-Version: 1.0 Subject: [Xen-devel] [PATCH v3 15/22] golang/xenlight: begin C to Go type marshaling X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Nick Rosbrook , Ian Jackson , kerriganb@ainfosec.com, George Dunlap , Wei Liu Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" From: Nick Rosbrook Begin implementation of fromC marshaling functions for generated struct types. This includes support for converting fields that are basic primitive types such as string and integer types, nested anonymous structs, nested libxl structs, and libxl built-in types. This patch does not implement conversion of arrays or keyed unions. Signed-off-by: Nick Rosbrook Reviewed-by: George Dunlap --- Changes in v2: - Add Makefile changes for helpers.gen.go. - Re-generate helpers.gen.go to include libxl changes after rebase. Changes in v3: - Break out field copying/type conversion code into its own function called xenlight_golang_convert_from_C to allow that code to be easily re-used. - Use consistent style for calling fromC on struct fields that require it. Namely, do not use a temporary variable - call fromC directly on the struct field. --- tools/golang/xenlight/Makefile | 2 + tools/golang/xenlight/gengotypes.py | 118 ++++ tools/golang/xenlight/helpers.gen.go | 901 +++++++++++++++++++++++++++ tools/golang/xenlight/xenlight.go | 111 +--- 4 files changed, 1032 insertions(+), 100 deletions(-) create mode 100644 tools/golang/xenlight/helpers.gen.go diff --git a/tools/golang/xenlight/Makefile b/tools/golang/xenlight/Makefile index 681f32c234..07b8896e5b 100644 --- a/tools/golang/xenlight/Makefile +++ b/tools/golang/xenlight/Makefile @@ -19,6 +19,7 @@ $(XEN_GOPATH)/src/$(XEN_GOCODE_URL)/xenlight/: %.gen.go $(INSTALL_DIR) $(XEN_GOPATH)$(GOXL_PKG_DIR) $(INSTALL_DATA) xenlight.go $(XEN_GOPATH)$(GOXL_PKG_DIR) $(INSTALL_DATA) types.gen.go $(XEN_GOPATH)$(GOXL_PKG_DIR) + $(INSTALL_DATA) helpers.gen.go $(XEN_GOPATH)$(GOXL_PKG_DIR) %.gen.go: gengotypes.py $(XEN_ROOT)/tools/libxl/libxl_types.idl $(XEN_ROOT)/tools/libxl/idl.py XEN_ROOT=$(XEN_ROOT) $(PYTHON) gengotypes.py ../../libxl/libxl_types.idl @@ -39,6 +40,7 @@ install: build $(INSTALL_DIR) $(DESTDIR)$(GOXL_INSTALL_DIR) $(INSTALL_DATA) $(XEN_GOPATH)$(GOXL_PKG_DIR)xenlight.go $(DESTDIR)$(GOXL_INSTALL_DIR) $(INSTALL_DATA) $(XEN_GOPATH)$(GOXL_PKG_DIR)types.gen.go $(DESTDIR)$(GOXL_INSTALL_DIR) + $(INSTALL_DATA) $(XEN_GOPATH)$(GOXL_PKG_DIR)helpers.gen.go $(DESTDIR)$(GOXL_INSTALL_DIR) .PHONY: uninstall rm -rf $(DESTDIR)$(GOXL_INSTALL_DIR) diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py index 8963b14eee..1fe56179e2 100644 --- a/tools/golang/xenlight/gengotypes.py +++ b/tools/golang/xenlight/gengotypes.py @@ -18,6 +18,12 @@ builtin_type_names = { idl.uint64.typename: 'uint64', } +# Some go keywords that conflict with field names in libxl structs. +go_keywords = ['type', 'func'] + +go_builtin_types = ['bool', 'string', 'int', 'byte', + 'uint16', 'uint32', 'uint64'] + def xenlight_golang_generate_types(path = None, types = None, comment = None): """ Generate a .go file (types.gen.go by default) @@ -176,6 +182,116 @@ def xenlight_golang_define_union(ty = None, structname = ''): return (s,extras) +def xenlight_golang_generate_helpers(path = None, types = None, comment = None): + """ + Generate a .go file (helpers.gen.go by default) + that contains helper functions for marshaling between + C and Go types. + """ + if path is None: + path = 'helpers.gen.go' + + with open(path, 'w') as f: + if comment is not None: + f.write(comment) + f.write('package xenlight\n') + + # Cgo preamble + f.write('/*\n') + f.write('#cgo LDFLAGS: -lxenlight\n') + f.write('#include \n') + f.write('#include \n') + f.write('\n') + + f.write('*/\nimport "C"\n') + + for ty in types: + if not isinstance(ty, idl.Struct): + continue + + f.write(xenlight_golang_define_from_C(ty)) + f.write('\n') + + go_fmt(path) + +def xenlight_golang_define_from_C(ty = None): + """ + Define the fromC marshaling function for the type + represented by ty. + """ + func = 'func (x *{}) fromC(xc *C.{}) error {{\n {} \n return nil}}\n' + + goname = xenlight_golang_fmt_name(ty.typename) + cname = ty.typename + + body = '' + + for f in ty.fields: + if f.type.typename is not None: + if isinstance(f.type, idl.Array): + # TODO + continue + + body += xenlight_golang_convert_from_C(f) + + elif isinstance(f.type, idl.Struct): + # Go through the fields of the anonymous nested struct. + for nf in f.type.fields: + body += xenlight_golang_convert_from_C(nf,outer_name=f.name) + + elif isinstance(f.type, idl.KeyedUnion): + pass + + else: + raise Exception('type {} not supported'.format(f.type)) + + return func.format(goname, cname, body) + +def xenlight_golang_convert_from_C(ty = None, outer_name = None): + """ + Returns a line of Go code that converts the C type represented + by ty to its corresponding Go type. + + If outer_name is set, the type is treated as nested within another field + named outer_name. + """ + s = '' + + gotypename = xenlight_golang_fmt_name(ty.type.typename) + goname = xenlight_golang_fmt_name(ty.name) + cname = ty.name + + # In cgo, C names that conflict with Go keywords can be + # accessed by prepending an underscore to the name. + if cname in go_keywords: + cname = '_' + cname + + # If outer_name is set, treat this as nested. + if outer_name is not None: + goname = '{}.{}'.format(xenlight_golang_fmt_name(outer_name), goname) + cname = '{}.{}'.format(outer_name, cname) + + # Types that satisfy this condition can be easily casted or + # converted to a Go builtin type. + is_castable = (ty.type.json_parse_type == 'JSON_INTEGER' or + isinstance(ty.type, idl.Enumeration) or + gotypename in go_builtin_types) + + if not is_castable: + # If the type is not castable, we need to call its fromC + # function. + s += 'if err := x.{}.fromC(&xc.{});'.format(goname,cname) + s += 'err != nil {\n return err \n}\n' + + elif gotypename == 'string': + # Use the cgo helper for converting C strings. + s += 'x.{} = C.GoString(xc.{})\n'.format(goname, cname) + + else: + s += 'x.{} = {}(xc.{})\n'.format(goname, gotypename, cname) + + return s + def xenlight_golang_fmt_name(name, exported = True): """ Take a given type name and return an @@ -218,3 +334,5 @@ if __name__ == '__main__': xenlight_golang_generate_types(types=types, comment=header_comment) + xenlight_golang_generate_helpers(types=types, + comment=header_comment) diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/helpers.gen.go new file mode 100644 index 0000000000..576aebcf6d --- /dev/null +++ b/tools/golang/xenlight/helpers.gen.go @@ -0,0 +1,901 @@ +// DO NOT EDIT. +// +// This file is generated by: +// gengotypes.py ../../libxl/libxl_types.idl +// +package xenlight + +/* +#cgo LDFLAGS: -lxenlight +#include +#include + +*/ +import "C" + +func (x *IoportRange) fromC(xc *C.libxl_ioport_range) error { + x.First = uint32(xc.first) + x.Number = uint32(xc.number) + + return nil +} + +func (x *IomemRange) fromC(xc *C.libxl_iomem_range) error { + x.Start = uint64(xc.start) + x.Number = uint64(xc.number) + x.Gfn = uint64(xc.gfn) + + return nil +} + +func (x *VgaInterfaceInfo) fromC(xc *C.libxl_vga_interface_info) error { + x.Kind = VgaInterfaceType(xc.kind) + + return nil +} + +func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error { + if err := x.Enable.fromC(&xc.enable); err != nil { + return err + } + x.Listen = C.GoString(xc.listen) + x.Passwd = C.GoString(xc.passwd) + x.Display = int(xc.display) + if err := x.Findunused.fromC(&xc.findunused); err != nil { + return err + } + + return nil +} + +func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error { + if err := x.Enable.fromC(&xc.enable); err != nil { + return err + } + x.Port = int(xc.port) + x.TlsPort = int(xc.tls_port) + x.Host = C.GoString(xc.host) + if err := x.DisableTicketing.fromC(&xc.disable_ticketing); err != nil { + return err + } + x.Passwd = C.GoString(xc.passwd) + if err := x.AgentMouse.fromC(&xc.agent_mouse); err != nil { + return err + } + if err := x.Vdagent.fromC(&xc.vdagent); err != nil { + return err + } + if err := x.ClipboardSharing.fromC(&xc.clipboard_sharing); err != nil { + return err + } + x.Usbredirection = int(xc.usbredirection) + x.ImageCompression = C.GoString(xc.image_compression) + x.StreamingVideo = C.GoString(xc.streaming_video) + + return nil +} + +func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error { + if err := x.Enable.fromC(&xc.enable); err != nil { + return err + } + if err := x.Opengl.fromC(&xc.opengl); err != nil { + return err + } + x.Display = C.GoString(xc.display) + x.Xauthority = C.GoString(xc.xauthority) + + return nil +} + +func (x *Dominfo) fromC(xc *C.libxl_dominfo) error { + if err := x.Uuid.fromC(&xc.uuid); err != nil { + return err + } + x.Domid = Domid(xc.domid) + x.Ssidref = uint32(xc.ssidref) + x.SsidLabel = C.GoString(xc.ssid_label) + x.Running = bool(xc.running) + x.Blocked = bool(xc.blocked) + x.Paused = bool(xc.paused) + x.Shutdown = bool(xc.shutdown) + x.Dying = bool(xc.dying) + x.NeverStop = bool(xc.never_stop) + x.ShutdownReason = ShutdownReason(xc.shutdown_reason) + x.OutstandingMemkb = uint64(xc.outstanding_memkb) + x.CurrentMemkb = uint64(xc.current_memkb) + x.SharedMemkb = uint64(xc.shared_memkb) + x.PagedMemkb = uint64(xc.paged_memkb) + x.MaxMemkb = uint64(xc.max_memkb) + x.CpuTime = uint64(xc.cpu_time) + x.VcpuMaxId = uint32(xc.vcpu_max_id) + x.VcpuOnline = uint32(xc.vcpu_online) + x.Cpupool = uint32(xc.cpupool) + x.DomainType = DomainType(xc.domain_type) + + return nil +} + +func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) error { + x.Poolid = uint32(xc.poolid) + x.PoolName = C.GoString(xc.pool_name) + x.Sched = Scheduler(xc.sched) + x.NDom = uint32(xc.n_dom) + if err := x.Cpumap.fromC(&xc.cpumap); err != nil { + return err + } + + return nil +} + +func (x *Channelinfo) fromC(xc *C.libxl_channelinfo) error { + x.Backend = C.GoString(xc.backend) + x.BackendId = uint32(xc.backend_id) + x.Frontend = C.GoString(xc.frontend) + x.FrontendId = uint32(xc.frontend_id) + x.Devid = Devid(xc.devid) + x.State = int(xc.state) + x.Evtch = int(xc.evtch) + x.Rref = int(xc.rref) + + return nil +} + +func (x *Vminfo) fromC(xc *C.libxl_vminfo) error { + if err := x.Uuid.fromC(&xc.uuid); err != nil { + return err + } + x.Domid = Domid(xc.domid) + + return nil +} + +func (x *VersionInfo) fromC(xc *C.libxl_version_info) error { + x.XenVersionMajor = int(xc.xen_version_major) + x.XenVersionMinor = int(xc.xen_version_minor) + x.XenVersionExtra = C.GoString(xc.xen_version_extra) + x.Compiler = C.GoString(xc.compiler) + x.CompileBy = C.GoString(xc.compile_by) + x.CompileDomain = C.GoString(xc.compile_domain) + x.CompileDate = C.GoString(xc.compile_date) + x.Capabilities = C.GoString(xc.capabilities) + x.Changeset = C.GoString(xc.changeset) + x.VirtStart = uint64(xc.virt_start) + x.Pagesize = int(xc.pagesize) + x.Commandline = C.GoString(xc.commandline) + x.BuildId = C.GoString(xc.build_id) + + return nil +} + +func (x *DomainCreateInfo) fromC(xc *C.libxl_domain_create_info) error { + x.Type = DomainType(xc._type) + if err := x.Hap.fromC(&xc.hap); err != nil { + return err + } + if err := x.Oos.fromC(&xc.oos); err != nil { + return err + } + x.Ssidref = uint32(xc.ssidref) + x.SsidLabel = C.GoString(xc.ssid_label) + x.Name = C.GoString(xc.name) + if err := x.Uuid.fromC(&xc.uuid); err != nil { + return err + } + if err := x.Xsdata.fromC(&xc.xsdata); err != nil { + return err + } + if err := x.Platformdata.fromC(&xc.platformdata); err != nil { + return err + } + x.Poolid = uint32(xc.poolid) + x.PoolName = C.GoString(xc.pool_name) + if err := x.RunHotplugScripts.fromC(&xc.run_hotplug_scripts); err != nil { + return err + } + if err := x.DriverDomain.fromC(&xc.driver_domain); err != nil { + return err + } + x.Passthrough = Passthrough(xc.passthrough) + + return nil +} + +func (x *DomainRestoreParams) fromC(xc *C.libxl_domain_restore_params) error { + x.CheckpointedStream = int(xc.checkpointed_stream) + x.StreamVersion = uint32(xc.stream_version) + x.ColoProxyScript = C.GoString(xc.colo_proxy_script) + if err := x.UserspaceColoProxy.fromC(&xc.userspace_colo_proxy); err != nil { + return err + } + + return nil +} + +func (x *SchedParams) fromC(xc *C.libxl_sched_params) error { + x.Vcpuid = int(xc.vcpuid) + x.Weight = int(xc.weight) + x.Cap = int(xc.cap) + x.Period = int(xc.period) + x.Extratime = int(xc.extratime) + x.Budget = int(xc.budget) + + return nil +} + +func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error { + x.Sched = Scheduler(xc.sched) + + return nil +} + +func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error { + x.Sched = Scheduler(xc.sched) + x.Weight = int(xc.weight) + x.Cap = int(xc.cap) + x.Period = int(xc.period) + x.Budget = int(xc.budget) + x.Extratime = int(xc.extratime) + x.Slice = int(xc.slice) + x.Latency = int(xc.latency) + + return nil +} + +func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error { + x.Memkb = uint64(xc.memkb) + x.Pnode = uint32(xc.pnode) + if err := x.Vcpus.fromC(&xc.vcpus); err != nil { + return err + } + + return nil +} + +func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) error { + x.Strategy = RdmReserveStrategy(xc.strategy) + x.Policy = RdmReservePolicy(xc.policy) + + return nil +} + +func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error { + x.MaxVcpus = int(xc.max_vcpus) + if err := x.AvailVcpus.fromC(&xc.avail_vcpus); err != nil { + return err + } + if err := x.Cpumap.fromC(&xc.cpumap); err != nil { + return err + } + if err := x.Nodemap.fromC(&xc.nodemap); err != nil { + return err + } + if err := x.NumaPlacement.fromC(&xc.numa_placement); err != nil { + return err + } + x.TscMode = TscMode(xc.tsc_mode) + x.MaxMemkb = uint64(xc.max_memkb) + x.TargetMemkb = uint64(xc.target_memkb) + x.VideoMemkb = uint64(xc.video_memkb) + x.ShadowMemkb = uint64(xc.shadow_memkb) + x.IommuMemkb = uint64(xc.iommu_memkb) + x.RtcTimeoffset = uint32(xc.rtc_timeoffset) + x.ExecSsidref = uint32(xc.exec_ssidref) + x.ExecSsidLabel = C.GoString(xc.exec_ssid_label) + if err := x.Localtime.fromC(&xc.localtime); err != nil { + return err + } + if err := x.DisableMigrate.fromC(&xc.disable_migrate); err != nil { + return err + } + if err := x.Cpuid.fromC(&xc.cpuid); err != nil { + return err + } + x.BlkdevStart = C.GoString(xc.blkdev_start) + x.MaxGrantFrames = uint32(xc.max_grant_frames) + x.MaxMaptrackFrames = uint32(xc.max_maptrack_frames) + x.DeviceModelVersion = DeviceModelVersion(xc.device_model_version) + if err := x.DeviceModelStubdomain.fromC(&xc.device_model_stubdomain); err != nil { + return err + } + x.DeviceModel = C.GoString(xc.device_model) + x.DeviceModelSsidref = uint32(xc.device_model_ssidref) + x.DeviceModelSsidLabel = C.GoString(xc.device_model_ssid_label) + x.DeviceModelUser = C.GoString(xc.device_model_user) + if err := x.Extra.fromC(&xc.extra); err != nil { + return err + } + if err := x.ExtraPv.fromC(&xc.extra_pv); err != nil { + return err + } + if err := x.ExtraHvm.fromC(&xc.extra_hvm); err != nil { + return err + } + if err := x.SchedParams.fromC(&xc.sched_params); err != nil { + return err + } + if err := x.ClaimMode.fromC(&xc.claim_mode); err != nil { + return err + } + x.EventChannels = uint32(xc.event_channels) + x.Kernel = C.GoString(xc.kernel) + x.Cmdline = C.GoString(xc.cmdline) + x.Ramdisk = C.GoString(xc.ramdisk) + x.DeviceTree = C.GoString(xc.device_tree) + if err := x.Acpi.fromC(&xc.acpi); err != nil { + return err + } + x.Bootloader = C.GoString(xc.bootloader) + if err := x.BootloaderArgs.fromC(&xc.bootloader_args); err != nil { + return err + } + x.TimerMode = TimerMode(xc.timer_mode) + if err := x.NestedHvm.fromC(&xc.nested_hvm); err != nil { + return err + } + if err := x.Apic.fromC(&xc.apic); err != nil { + return err + } + if err := x.DmRestrict.fromC(&xc.dm_restrict); err != nil { + return err + } + x.Tee = TeeType(xc.tee) + x.ArchArm.GicVersion = GicVersion(xc.arch_arm.gic_version) + x.ArchArm.Vuart = VuartType(xc.arch_arm.vuart) + x.Altp2M = Altp2MMode(xc.altp2m) + + return nil +} + +func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) error { + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + x.Devid = Devid(xc.devid) + if err := x.Vnc.fromC(&xc.vnc); err != nil { + return err + } + if err := x.Sdl.fromC(&xc.sdl); err != nil { + return err + } + x.Keymap = C.GoString(xc.keymap) + + return nil +} + +func (x *DeviceVkb) fromC(xc *C.libxl_device_vkb) error { + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + x.Devid = Devid(xc.devid) + x.BackendType = VkbBackend(xc.backend_type) + x.UniqueId = C.GoString(xc.unique_id) + x.FeatureDisableKeyboard = bool(xc.feature_disable_keyboard) + x.FeatureDisablePointer = bool(xc.feature_disable_pointer) + x.FeatureAbsPointer = bool(xc.feature_abs_pointer) + x.FeatureRawPointer = bool(xc.feature_raw_pointer) + x.FeatureMultiTouch = bool(xc.feature_multi_touch) + x.Width = uint32(xc.width) + x.Height = uint32(xc.height) + x.MultiTouchWidth = uint32(xc.multi_touch_width) + x.MultiTouchHeight = uint32(xc.multi_touch_height) + x.MultiTouchNumContacts = uint32(xc.multi_touch_num_contacts) + + return nil +} + +func (x *DeviceDisk) fromC(xc *C.libxl_device_disk) error { + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + x.PdevPath = C.GoString(xc.pdev_path) + x.Vdev = C.GoString(xc.vdev) + x.Backend = DiskBackend(xc.backend) + x.Format = DiskFormat(xc.format) + x.Script = C.GoString(xc.script) + x.Removable = int(xc.removable) + x.Readwrite = int(xc.readwrite) + x.IsCdrom = int(xc.is_cdrom) + x.DirectIoSafe = bool(xc.direct_io_safe) + if err := x.DiscardEnable.fromC(&xc.discard_enable); err != nil { + return err + } + if err := x.ColoEnable.fromC(&xc.colo_enable); err != nil { + return err + } + if err := x.ColoRestoreEnable.fromC(&xc.colo_restore_enable); err != nil { + return err + } + x.ColoHost = C.GoString(xc.colo_host) + x.ColoPort = int(xc.colo_port) + x.ColoExport = C.GoString(xc.colo_export) + x.ActiveDisk = C.GoString(xc.active_disk) + x.HiddenDisk = C.GoString(xc.hidden_disk) + + return nil +} + +func (x *DeviceNic) fromC(xc *C.libxl_device_nic) error { + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + x.Devid = Devid(xc.devid) + x.Mtu = int(xc.mtu) + x.Model = C.GoString(xc.model) + if err := x.Mac.fromC(&xc.mac); err != nil { + return err + } + x.Ip = C.GoString(xc.ip) + x.Bridge = C.GoString(xc.bridge) + x.Ifname = C.GoString(xc.ifname) + x.Script = C.GoString(xc.script) + x.Nictype = NicType(xc.nictype) + x.RateBytesPerInterval = uint64(xc.rate_bytes_per_interval) + x.RateIntervalUsecs = uint32(xc.rate_interval_usecs) + x.Gatewaydev = C.GoString(xc.gatewaydev) + x.ColoftForwarddev = C.GoString(xc.coloft_forwarddev) + x.ColoSockMirrorId = C.GoString(xc.colo_sock_mirror_id) + x.ColoSockMirrorIp = C.GoString(xc.colo_sock_mirror_ip) + x.ColoSockMirrorPort = C.GoString(xc.colo_sock_mirror_port) + x.ColoSockComparePriInId = C.GoString(xc.colo_sock_compare_pri_in_id) + x.ColoSockComparePriInIp = C.GoString(xc.colo_sock_compare_pri_in_ip) + x.ColoSockComparePriInPort = C.GoString(xc.colo_sock_compare_pri_in_port) + x.ColoSockCompareSecInId = C.GoString(xc.colo_sock_compare_sec_in_id) + x.ColoSockCompareSecInIp = C.GoString(xc.colo_sock_compare_sec_in_ip) + x.ColoSockCompareSecInPort = C.GoString(xc.colo_sock_compare_sec_in_port) + x.ColoSockCompareNotifyId = C.GoString(xc.colo_sock_compare_notify_id) + x.ColoSockCompareNotifyIp = C.GoString(xc.colo_sock_compare_notify_ip) + x.ColoSockCompareNotifyPort = C.GoString(xc.colo_sock_compare_notify_port) + x.ColoSockRedirector0Id = C.GoString(xc.colo_sock_redirector0_id) + x.ColoSockRedirector0Ip = C.GoString(xc.colo_sock_redirector0_ip) + x.ColoSockRedirector0Port = C.GoString(xc.colo_sock_redirector0_port) + x.ColoSockRedirector1Id = C.GoString(xc.colo_sock_redirector1_id) + x.ColoSockRedirector1Ip = C.GoString(xc.colo_sock_redirector1_ip) + x.ColoSockRedirector1Port = C.GoString(xc.colo_sock_redirector1_port) + x.ColoSockRedirector2Id = C.GoString(xc.colo_sock_redirector2_id) + x.ColoSockRedirector2Ip = C.GoString(xc.colo_sock_redirector2_ip) + x.ColoSockRedirector2Port = C.GoString(xc.colo_sock_redirector2_port) + x.ColoFilterMirrorQueue = C.GoString(xc.colo_filter_mirror_queue) + x.ColoFilterMirrorOutdev = C.GoString(xc.colo_filter_mirror_outdev) + x.ColoFilterRedirector0Queue = C.GoString(xc.colo_filter_redirector0_queue) + x.ColoFilterRedirector0Indev = C.GoString(xc.colo_filter_redirector0_indev) + x.ColoFilterRedirector0Outdev = C.GoString(xc.colo_filter_redirector0_outdev) + x.ColoFilterRedirector1Queue = C.GoString(xc.colo_filter_redirector1_queue) + x.ColoFilterRedirector1Indev = C.GoString(xc.colo_filter_redirector1_indev) + x.ColoFilterRedirector1Outdev = C.GoString(xc.colo_filter_redirector1_outdev) + x.ColoComparePriIn = C.GoString(xc.colo_compare_pri_in) + x.ColoCompareSecIn = C.GoString(xc.colo_compare_sec_in) + x.ColoCompareOut = C.GoString(xc.colo_compare_out) + x.ColoCompareNotifyDev = C.GoString(xc.colo_compare_notify_dev) + x.ColoSockSecRedirector0Id = C.GoString(xc.colo_sock_sec_redirector0_id) + x.ColoSockSecRedirector0Ip = C.GoString(xc.colo_sock_sec_redirector0_ip) + x.ColoSockSecRedirector0Port = C.GoString(xc.colo_sock_sec_redirector0_port) + x.ColoSockSecRedirector1Id = C.GoString(xc.colo_sock_sec_redirector1_id) + x.ColoSockSecRedirector1Ip = C.GoString(xc.colo_sock_sec_redirector1_ip) + x.ColoSockSecRedirector1Port = C.GoString(xc.colo_sock_sec_redirector1_port) + x.ColoFilterSecRedirector0Queue = C.GoString(xc.colo_filter_sec_redirector0_queue) + x.ColoFilterSecRedirector0Indev = C.GoString(xc.colo_filter_sec_redirector0_indev) + x.ColoFilterSecRedirector0Outdev = C.GoString(xc.colo_filter_sec_redirector0_outdev) + x.ColoFilterSecRedirector1Queue = C.GoString(xc.colo_filter_sec_redirector1_queue) + x.ColoFilterSecRedirector1Indev = C.GoString(xc.colo_filter_sec_redirector1_indev) + x.ColoFilterSecRedirector1Outdev = C.GoString(xc.colo_filter_sec_redirector1_outdev) + x.ColoFilterSecRewriter0Queue = C.GoString(xc.colo_filter_sec_rewriter0_queue) + x.ColoCheckpointHost = C.GoString(xc.colo_checkpoint_host) + x.ColoCheckpointPort = C.GoString(xc.colo_checkpoint_port) + + return nil +} + +func (x *DevicePci) fromC(xc *C.libxl_device_pci) error { + x.Func = byte(xc._func) + x.Dev = byte(xc.dev) + x.Bus = byte(xc.bus) + x.Domain = int(xc.domain) + x.Vdevfn = uint32(xc.vdevfn) + x.VfuncMask = uint32(xc.vfunc_mask) + x.Msitranslate = bool(xc.msitranslate) + x.PowerMgmt = bool(xc.power_mgmt) + x.Permissive = bool(xc.permissive) + x.Seize = bool(xc.seize) + x.RdmPolicy = RdmReservePolicy(xc.rdm_policy) + + return nil +} + +func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) error { + x.Start = uint64(xc.start) + x.Size = uint64(xc.size) + x.Policy = RdmReservePolicy(xc.policy) + + return nil +} + +func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error { + x.Type = UsbctrlType(xc._type) + x.Devid = Devid(xc.devid) + x.Version = int(xc.version) + x.Ports = int(xc.ports) + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + + return nil +} + +func (x *DeviceUsbdev) fromC(xc *C.libxl_device_usbdev) error { + x.Ctrl = Devid(xc.ctrl) + x.Port = int(xc.port) + + return nil +} + +func (x *DeviceDtdev) fromC(xc *C.libxl_device_dtdev) error { + x.Path = C.GoString(xc.path) + + return nil +} + +func (x *DeviceVtpm) fromC(xc *C.libxl_device_vtpm) error { + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + x.Devid = Devid(xc.devid) + if err := x.Uuid.fromC(&xc.uuid); err != nil { + return err + } + + return nil +} + +func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error { + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + x.Tag = C.GoString(xc.tag) + x.Path = C.GoString(xc.path) + x.SecurityModel = C.GoString(xc.security_model) + x.Devid = Devid(xc.devid) + + return nil +} + +func (x *DevicePvcallsif) fromC(xc *C.libxl_device_pvcallsif) error { + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + x.Devid = Devid(xc.devid) + + return nil +} + +func (x *DeviceChannel) fromC(xc *C.libxl_device_channel) error { + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + x.Devid = Devid(xc.devid) + x.Name = C.GoString(xc.name) + + return nil +} + +func (x *ConnectorParam) fromC(xc *C.libxl_connector_param) error { + x.UniqueId = C.GoString(xc.unique_id) + x.Width = uint32(xc.width) + x.Height = uint32(xc.height) + + return nil +} + +func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdispl) error { + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + x.Devid = Devid(xc.devid) + x.BeAlloc = bool(xc.be_alloc) + + return nil +} + +func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error { + x.ChannelsMin = uint32(xc.channels_min) + x.ChannelsMax = uint32(xc.channels_max) + x.BufferSize = uint32(xc.buffer_size) + + return nil +} + +func (x *VsndStream) fromC(xc *C.libxl_vsnd_stream) error { + x.UniqueId = C.GoString(xc.unique_id) + x.Type = VsndStreamType(xc._type) + if err := x.Params.fromC(&xc.params); err != nil { + return err + } + + return nil +} + +func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error { + x.Name = C.GoString(xc.name) + if err := x.Params.fromC(&xc.params); err != nil { + return err + } + + return nil +} + +func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error { + x.BackendDomid = Domid(xc.backend_domid) + x.BackendDomname = C.GoString(xc.backend_domname) + x.Devid = Devid(xc.devid) + x.ShortName = C.GoString(xc.short_name) + x.LongName = C.GoString(xc.long_name) + if err := x.Params.fromC(&xc.params); err != nil { + return err + } + + return nil +} + +func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error { + if err := x.CInfo.fromC(&xc.c_info); err != nil { + return err + } + if err := x.BInfo.fromC(&xc.b_info); err != nil { + return err + } + x.OnPoweroff = ActionOnShutdown(xc.on_poweroff) + x.OnReboot = ActionOnShutdown(xc.on_reboot) + x.OnWatchdog = ActionOnShutdown(xc.on_watchdog) + x.OnCrash = ActionOnShutdown(xc.on_crash) + x.OnSoftReset = ActionOnShutdown(xc.on_soft_reset) + + return nil +} + +func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error { + x.Backend = C.GoString(xc.backend) + x.BackendId = uint32(xc.backend_id) + x.Frontend = C.GoString(xc.frontend) + x.FrontendId = uint32(xc.frontend_id) + x.Devid = Devid(xc.devid) + x.State = int(xc.state) + x.Evtch = int(xc.evtch) + x.Rref = int(xc.rref) + + return nil +} + +func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error { + x.Backend = C.GoString(xc.backend) + x.BackendId = uint32(xc.backend_id) + x.Frontend = C.GoString(xc.frontend) + x.FrontendId = uint32(xc.frontend_id) + x.Devid = Devid(xc.devid) + x.State = int(xc.state) + x.Evtch = int(xc.evtch) + x.RrefTx = int(xc.rref_tx) + x.RrefRx = int(xc.rref_rx) + + return nil +} + +func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error { + x.Backend = C.GoString(xc.backend) + x.BackendId = uint32(xc.backend_id) + x.Frontend = C.GoString(xc.frontend) + x.FrontendId = uint32(xc.frontend_id) + x.Devid = Devid(xc.devid) + x.State = int(xc.state) + x.Evtch = int(xc.evtch) + x.Rref = int(xc.rref) + if err := x.Uuid.fromC(&xc.uuid); err != nil { + return err + } + + return nil +} + +func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo) error { + x.Type = UsbctrlType(xc._type) + x.Devid = Devid(xc.devid) + x.Version = int(xc.version) + x.Ports = int(xc.ports) + x.Backend = C.GoString(xc.backend) + x.BackendId = uint32(xc.backend_id) + x.Frontend = C.GoString(xc.frontend) + x.FrontendId = uint32(xc.frontend_id) + x.State = int(xc.state) + x.Evtch = int(xc.evtch) + x.RefUrb = int(xc.ref_urb) + x.RefConn = int(xc.ref_conn) + + return nil +} + +func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error { + x.Vcpuid = uint32(xc.vcpuid) + x.Cpu = uint32(xc.cpu) + x.Online = bool(xc.online) + x.Blocked = bool(xc.blocked) + x.Running = bool(xc.running) + x.VcpuTime = uint64(xc.vcpu_time) + if err := x.Cpumap.fromC(&xc.cpumap); err != nil { + return err + } + if err := x.CpumapSoft.fromC(&xc.cpumap_soft); err != nil { + return err + } + + return nil +} + +func (x *Physinfo) fromC(xc *C.libxl_physinfo) error { + x.ThreadsPerCore = uint32(xc.threads_per_core) + x.CoresPerSocket = uint32(xc.cores_per_socket) + x.MaxCpuId = uint32(xc.max_cpu_id) + x.NrCpus = uint32(xc.nr_cpus) + x.CpuKhz = uint32(xc.cpu_khz) + x.TotalPages = uint64(xc.total_pages) + x.FreePages = uint64(xc.free_pages) + x.ScrubPages = uint64(xc.scrub_pages) + x.OutstandingPages = uint64(xc.outstanding_pages) + x.SharingFreedPages = uint64(xc.sharing_freed_pages) + x.SharingUsedFrames = uint64(xc.sharing_used_frames) + x.MaxPossibleMfn = uint64(xc.max_possible_mfn) + x.NrNodes = uint32(xc.nr_nodes) + if err := x.HwCap.fromC(&xc.hw_cap); err != nil { + return err + } + x.CapHvm = bool(xc.cap_hvm) + x.CapPv = bool(xc.cap_pv) + x.CapHvmDirectio = bool(xc.cap_hvm_directio) + x.CapHap = bool(xc.cap_hap) + x.CapShadow = bool(xc.cap_shadow) + x.CapIommuHapPtShare = bool(xc.cap_iommu_hap_pt_share) + + return nil +} + +func (x *Connectorinfo) fromC(xc *C.libxl_connectorinfo) error { + x.UniqueId = C.GoString(xc.unique_id) + x.Width = uint32(xc.width) + x.Height = uint32(xc.height) + x.ReqEvtch = int(xc.req_evtch) + x.ReqRref = int(xc.req_rref) + x.EvtEvtch = int(xc.evt_evtch) + x.EvtRref = int(xc.evt_rref) + + return nil +} + +func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error { + x.Backend = C.GoString(xc.backend) + x.BackendId = uint32(xc.backend_id) + x.Frontend = C.GoString(xc.frontend) + x.FrontendId = uint32(xc.frontend_id) + x.Devid = Devid(xc.devid) + x.State = int(xc.state) + x.BeAlloc = bool(xc.be_alloc) + + return nil +} + +func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error { + x.ReqEvtch = int(xc.req_evtch) + x.ReqRref = int(xc.req_rref) + + return nil +} + +func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error { + + return nil +} + +func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error { + x.Backend = C.GoString(xc.backend) + x.BackendId = uint32(xc.backend_id) + x.Frontend = C.GoString(xc.frontend) + x.FrontendId = uint32(xc.frontend_id) + x.Devid = Devid(xc.devid) + x.State = int(xc.state) + + return nil +} + +func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error { + x.Backend = C.GoString(xc.backend) + x.BackendId = uint32(xc.backend_id) + x.Frontend = C.GoString(xc.frontend) + x.FrontendId = uint32(xc.frontend_id) + x.Devid = Devid(xc.devid) + x.State = int(xc.state) + x.Evtch = int(xc.evtch) + x.Rref = int(xc.rref) + + return nil +} + +func (x *Numainfo) fromC(xc *C.libxl_numainfo) error { + x.Size = uint64(xc.size) + x.Free = uint64(xc.free) + + return nil +} + +func (x *Cputopology) fromC(xc *C.libxl_cputopology) error { + x.Core = uint32(xc.core) + x.Socket = uint32(xc.socket) + x.Node = uint32(xc.node) + + return nil +} + +func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error { + x.Seg = uint16(xc.seg) + x.Bus = byte(xc.bus) + x.Devfn = byte(xc.devfn) + x.Node = uint32(xc.node) + + return nil +} + +func (x *SchedCreditParams) fromC(xc *C.libxl_sched_credit_params) error { + x.TsliceMs = int(xc.tslice_ms) + x.RatelimitUs = int(xc.ratelimit_us) + x.VcpuMigrDelayUs = int(xc.vcpu_migr_delay_us) + + return nil +} + +func (x *SchedCredit2Params) fromC(xc *C.libxl_sched_credit2_params) error { + x.RatelimitUs = int(xc.ratelimit_us) + + return nil +} + +func (x *DomainRemusInfo) fromC(xc *C.libxl_domain_remus_info) error { + x.Interval = int(xc.interval) + if err := x.AllowUnsafe.fromC(&xc.allow_unsafe); err != nil { + return err + } + if err := x.Blackhole.fromC(&xc.blackhole); err != nil { + return err + } + if err := x.Compression.fromC(&xc.compression); err != nil { + return err + } + if err := x.Netbuf.fromC(&xc.netbuf); err != nil { + return err + } + x.Netbufscript = C.GoString(xc.netbufscript) + if err := x.Diskbuf.fromC(&xc.diskbuf); err != nil { + return err + } + if err := x.Colo.fromC(&xc.colo); err != nil { + return err + } + if err := x.UserspaceColoProxy.fromC(&xc.userspace_colo_proxy); err != nil { + return err + } + + return nil +} + +func (x *Event) fromC(xc *C.libxl_event) error { + if err := x.Link.fromC(&xc.link); err != nil { + return err + } + x.Domid = Domid(xc.domid) + if err := x.Domuuid.fromC(&xc.domuuid); err != nil { + return err + } + x.ForUser = uint64(xc.for_user) + + return nil +} + +func (x *PsrCatInfo) fromC(xc *C.libxl_psr_cat_info) error { + x.Id = uint32(xc.id) + x.CosMax = uint32(xc.cos_max) + x.CbmLen = uint32(xc.cbm_len) + x.CdpEnabled = bool(xc.cdp_enabled) + + return nil +} + +func (x *PsrHwInfo) fromC(xc *C.libxl_psr_hw_info) error { + x.Id = uint32(xc.id) + + return nil +} diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenlight.go index fb1c6d9e51..f32eb11384 100644 --- a/tools/golang/xenlight/xenlight.go +++ b/tools/golang/xenlight/xenlight.go @@ -405,47 +405,6 @@ func (bm *Bitmap) toC() (C.libxl_bitmap, error) { return cbm, nil } -func (cphys *C.libxl_physinfo) toGo() (physinfo *Physinfo) { - - physinfo = &Physinfo{} - physinfo.ThreadsPerCore = uint32(cphys.threads_per_core) - physinfo.CoresPerSocket = uint32(cphys.cores_per_socket) - physinfo.MaxCpuId = uint32(cphys.max_cpu_id) - physinfo.NrCpus = uint32(cphys.nr_cpus) - physinfo.CpuKhz = uint32(cphys.cpu_khz) - physinfo.TotalPages = uint64(cphys.total_pages) - physinfo.FreePages = uint64(cphys.free_pages) - physinfo.ScrubPages = uint64(cphys.scrub_pages) - physinfo.ScrubPages = uint64(cphys.scrub_pages) - physinfo.SharingFreedPages = uint64(cphys.sharing_freed_pages) - physinfo.SharingUsedFrames = uint64(cphys.sharing_used_frames) - physinfo.NrNodes = uint32(cphys.nr_nodes) - physinfo.HwCap.fromC(&cphys.hw_cap) - physinfo.CapHvm = bool(cphys.cap_hvm) - physinfo.CapHvmDirectio = bool(cphys.cap_hvm_directio) - - return -} - -func (cinfo *C.libxl_version_info) toGo() (info *VersionInfo) { - info = &VersionInfo{} - info.XenVersionMajor = int(cinfo.xen_version_major) - info.XenVersionMinor = int(cinfo.xen_version_minor) - info.XenVersionExtra = C.GoString(cinfo.xen_version_extra) - info.Compiler = C.GoString(cinfo.compiler) - info.CompileBy = C.GoString(cinfo.compile_by) - info.CompileDomain = C.GoString(cinfo.compile_domain) - info.CompileDate = C.GoString(cinfo.compile_date) - info.Capabilities = C.GoString(cinfo.capabilities) - info.Changeset = C.GoString(cinfo.changeset) - info.VirtStart = uint64(cinfo.virt_start) - info.Pagesize = int(cinfo.pagesize) - info.Commandline = C.GoString(cinfo.commandline) - info.BuildId = C.GoString(cinfo.build_id) - - return -} - func (sr ShutdownReason) String() (str string) { cstr := C.libxl_shutdown_reason_to_string(C.libxl_shutdown_reason(sr)) str = C.GoString(cstr) @@ -460,34 +419,6 @@ func (dt DomainType) String() (str string) { return } -func (cdi *C.libxl_dominfo) toGo() (di *Dominfo) { - - di = &Dominfo{} - di.Uuid.fromC(&cdi.uuid) - di.Domid = Domid(cdi.domid) - di.Ssidref = uint32(cdi.ssidref) - di.SsidLabel = C.GoString(cdi.ssid_label) - di.Running = bool(cdi.running) - di.Blocked = bool(cdi.blocked) - di.Paused = bool(cdi.paused) - di.Shutdown = bool(cdi.shutdown) - di.Dying = bool(cdi.dying) - di.NeverStop = bool(cdi.never_stop) - di.ShutdownReason = ShutdownReason(cdi.shutdown_reason) - di.OutstandingMemkb = uint64(cdi.outstanding_memkb) - di.CurrentMemkb = uint64(cdi.current_memkb) - di.SharedMemkb = uint64(cdi.shared_memkb) - di.PagedMemkb = uint64(cdi.paged_memkb) - di.MaxMemkb = uint64(cdi.max_memkb) - di.CpuTime = uint64(cdi.cpu_time) - di.VcpuMaxId = uint32(cdi.vcpu_max_id) - di.VcpuOnline = uint32(cdi.vcpu_online) - di.Cpupool = uint32(cdi.cpupool) - di.DomainType = DomainType(cdi.domain_type) - - return -} - // const char *libxl_scheduler_to_string(libxl_scheduler p); func (s Scheduler) String() string { cs := C.libxl_scheduler_to_string(C.libxl_scheduler(s)) @@ -519,16 +450,6 @@ func SchedulerFromString(name string) (s Scheduler, err error) { return } -func (cci C.libxl_cpupoolinfo) toGo() (gci Cpupoolinfo) { - gci.Poolid = uint32(cci.poolid) - gci.PoolName = C.GoString(cci.pool_name) - gci.Sched = Scheduler(cci.sched) - gci.NDom = uint32(cci.n_dom) - gci.Cpumap.fromC(&cci.cpumap) - - return -} - // libxl_cpupoolinfo * libxl_list_cpupool(libxl_ctx*, int *nb_pool_out); // void libxl_cpupoolinfo_list_free(libxl_cpupoolinfo *list, int nb_pool); func (Ctx *Context) ListCpupool() (list []Cpupoolinfo) { @@ -550,7 +471,8 @@ func (Ctx *Context) ListCpupool() (list []Cpupoolinfo) { // Magic cpupoolListSlice := (*[1 << 30]C.libxl_cpupoolinfo)(unsafe.Pointer(c_cpupool_list))[:nbPool:nbPool] for i := range cpupoolListSlice { - info := cpupoolListSlice[i].toGo() + var info Cpupoolinfo + _ = info.fromC(&cpupoolListSlice[i]) list = append(list, info) } @@ -573,7 +495,7 @@ func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool Cpupoolinfo) { } defer C.libxl_cpupoolinfo_dispose(&c_cpupool) - pool = c_cpupool.toGo() + _ = pool.fromC(&c_cpupool) return } @@ -1064,7 +986,7 @@ func (Ctx *Context) GetPhysinfo() (physinfo *Physinfo, err error) { err = Error(ret) return } - physinfo = cphys.toGo() + err = physinfo.fromC(&cphys) return } @@ -1080,7 +1002,7 @@ func (Ctx *Context) GetVersionInfo() (info *VersionInfo, err error) { cinfo = C.libxl_get_version_info(Ctx.ctx) - info = cinfo.toGo() + err = info.fromC(cinfo) return } @@ -1102,7 +1024,7 @@ func (Ctx *Context) DomainInfo(Id Domid) (di *Dominfo, err error) { return } - di = cdi.toGo() + err = di.fromC(&cdi) return } @@ -1184,26 +1106,14 @@ func (Ctx *Context) ListDomain() (glist []Dominfo) { gslice := (*[1 << 30]C.libxl_dominfo)(unsafe.Pointer(clist))[:nbDomain:nbDomain] for i := range gslice { - info := gslice[i].toGo() - glist = append(glist, *info) + var info Dominfo + _ = info.fromC(&gslice[i]) + glist = append(glist, info) } return } -func (cvci C.libxl_vcpuinfo) toGo() (gvci Vcpuinfo) { - gvci.Vcpuid = uint32(cvci.vcpuid) - gvci.Cpu = uint32(cvci.cpu) - gvci.Online = bool(cvci.online) - gvci.Blocked = bool(cvci.blocked) - gvci.Running = bool(cvci.running) - gvci.VcpuTime = uint64(cvci.vcpu_time) - gvci.Cpumap.fromC(&cvci.cpumap) - gvci.CpumapSoft.fromC(&cvci.cpumap_soft) - - return -} - //libxl_vcpuinfo *libxl_list_vcpu(libxl_ctx *ctx, uint32_t domid, // int *nb_vcpu, int *nr_cpus_out); //void libxl_vcpuinfo_list_free(libxl_vcpuinfo *, int nr_vcpus); @@ -1225,7 +1135,8 @@ func (Ctx *Context) ListVcpu(id Domid) (glist []Vcpuinfo) { gslice := (*[1 << 30]C.libxl_vcpuinfo)(unsafe.Pointer(clist))[:nbVcpu:nbVcpu] for i := range gslice { - info := gslice[i].toGo() + var info Vcpuinfo + _ = info.fromC(&gslice[i]) glist = append(glist, info) }