From nobody Mon May 6 11:55:13 2024 Delivered-To: importer@patchew.org Received-SPF: none (zohomail.com: 192.237.175.120 is neither permitted nor denied by domain of lists.xenproject.org) client-ip=192.237.175.120; envelope-from=xen-devel-bounces@lists.xenproject.org; helo=lists.xenproject.org; Authentication-Results: mx.zohomail.com; dkim=fail; spf=none (zohomail.com: 192.237.175.120 is neither permitted nor denied by domain of lists.xenproject.org) smtp.mailfrom=xen-devel-bounces@lists.xenproject.org; dmarc=fail(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1578171748; cv=none; d=zohomail.com; s=zohoarc; b=bkBWE7DYkHKFmo3WfrS8Hnd+VbGv7touVSzA0o9ZYwDH58rhz77s3YFldP6C/8H2hX6RRaYwcreEytD//2plx0BRVKqrjRERzW13PGatWxNrCMZFdlBTOQb10pCj3GJuPkw0bSftEZoLRD0j5I4whvqQuBLr5U0/HBKWeWiGG6E= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1578171748; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=7rrRS/82t38erLAGVqr7a3C0eUC5EAXLsBAsZKnYptk=; b=VdbYZ5GtuyewyhGNCzZJIqQeGxuzVBD7q3Clu3mhIyYwRYfqhQwxHq8KKbS9Hqjd8kJ8ODvxd9zh3ChAMSo8vCbdIAKNcbdCkoz25/zjX8l0ynBkP3t14V3lpBL9gDs3O6gDIoCXvdMmni/iFrT7mKAS/n5ZA4LHmmGo56u9uQo= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=none (zohomail.com: 192.237.175.120 is neither permitted nor denied by domain of lists.xenproject.org) smtp.mailfrom=xen-devel-bounces@lists.xenproject.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) by mx.zohomail.com with SMTPS id 1578171748606533.4577185632863; Sat, 4 Jan 2020 13:02:28 -0800 (PST) Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1inqY2-0003F4-Ds; Sat, 04 Jan 2020 21:01:26 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1inqY1-0003Ey-G2 for xen-devel@lists.xenproject.org; Sat, 04 Jan 2020 21:01:25 +0000 Received: from mail-yb1-xb31.google.com (unknown [2607:f8b0:4864:20::b31]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 5bb30b72-2f35-11ea-a914-bc764e2007e4; Sat, 04 Jan 2020 21:01:20 +0000 (UTC) Received: by mail-yb1-xb31.google.com with SMTP id l7so12425796ybp.1 for ; Sat, 04 Jan 2020 13:01:20 -0800 (PST) Received: from four.lan (cpe-67-241-56-252.twcny.res.rr.com. [67.241.56.252]) by smtp.gmail.com with ESMTPSA id r10sm26366714ywr.97.2020.01.04.13.01.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 04 Jan 2020 13:01:18 -0800 (PST) X-Inumbo-ID: 5bb30b72-2f35-11ea-a914-bc764e2007e4 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 :in-reply-to:references; bh=CZfl/dl9ScYmQdwwhWaZQUW3IxIbwMKFNGj7gBDf/k0=; b=qjApG186HqrCzSJMFkTaUaSZXClronMbCiuRo6t+S08acncmHiu/+W8IFa+sMgasJ7 KsyL4E7fN1Kh048d/HFiMdK4nJ5SczUMuaqcoiOi5xR2TFYvIWwN4hfE9f237pD6f6Rf CvGy1LVZuIr9/8I9xyvtN3IX/HMlKDwKlvkq9NeGQnvxNiMMP6vKWAPUumWwKOKazsiS +qtQN97VGFCH7cUNObA53wYBGavoYvuDUjxw0QFbpTtL52LkHqp9nQkfST+Ymca1gXj+ bgOZGoV/OohL8rBebgEw3wEGMLczGxzwensvR+fdAVp9WetvLdyg8/AJ+nlNSdkBzoDg P5sw== 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:in-reply-to:references; bh=CZfl/dl9ScYmQdwwhWaZQUW3IxIbwMKFNGj7gBDf/k0=; b=PspsDvGLzQHMw1Eb31Yf4bRvAL+sSURnSnZTAT7Kdy6QB/HtifZOfSlgg1rVRj1+6L c/WQvityWTcaZDEOeBY9ho9M4U01Bc44I7uuWCZFd4PKvcp77mJhcYY5ySJ+aGk64zXH C3GdmzJ8aETukNuGmPBeFzryWoIDJ1oIgG13aq2o2Espkj04LUWt8HZxok1rsV1GOjFY VbJNmSB2p7yNjmMTPx/ObwOdcuHGUPSXlMHEwtOOgSZTVfS9YCFddBL3vLG1ct2ZzqYX gVTqkuZiIffwY7rGl29HTgZg4hGmSV+vPNAzFPb9EomiWoUS/RqEj2qkdQGAdlwzrdUq i5ow== X-Gm-Message-State: APjAAAX/+H4MVYayIVnGzSckPJRVoSqlLOnYVuKIvY0m2L55fan4s2UO iRa6pF+N7QkYE1Db5nKjslDYaYl7 X-Google-Smtp-Source: APXvYqw3pa4Wf4hoaKb/ZTXnm0EcQQHQqTul/7ruoKrfyloW4+0l3QcOel1MiD0gTuFrp3pR36R/fg== X-Received: by 2002:a25:d2d3:: with SMTP id j202mr67110040ybg.278.1578171678767; Sat, 04 Jan 2020 13:01:18 -0800 (PST) From: Nick Rosbrook X-Google-Original-From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Sat, 4 Jan 2020 16:00:51 -0500 Message-Id: <3a36857aeebe9a8ec3c4bc64f8ee77cdab035d6e.1578170151.git.rosbrookn@ainfosec.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Subject: [Xen-devel] [PATCH v5 1/3] golang/xenlight: begin Go to C 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 , George Dunlap , Wei Liu MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) 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 Reviewed-by: George Dunlap --- 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/ge= ngotypes.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 =3D None, typ= es =3D None, comment =3D None): f.write(extra) f.write('\n') =20 + f.write(xenlight_golang_define_to_C(ty)) + f.write('\n') + go_fmt(path) =20 def xenlight_golang_define_from_C(ty =3D None): @@ -434,6 +437,84 @@ def xenlight_golang_array_from_C(ty =3D None): =20 return s =20 +def xenlight_golang_define_to_C(ty =3D None, typename =3D None, nested =3D= False): + """ + Define the toC marshaling function for the type + represented by ty. + """ + func =3D 'func (x *{}) toC(xc *C.{}) (err error){{{}\n return nil \n }= }\n' + body =3D '' + + if ty.dispose_fn is not None: + body +=3D 'defer func(){{\nif err !=3D nil{{\nC.{}(xc)}}\n}}()\n\n= '.format(ty.dispose_fn) + + goname =3D xenlight_golang_fmt_name(ty.typename) + cname =3D ty.typename + + for f in ty.fields: + if f.type.typename is not None: + if isinstance(f.type, idl.Array): + # TODO + continue + + body +=3D xenlight_golang_convert_to_C(f) + + elif isinstance(f.type, idl.Struct): + for nf in f.type.fields: + body +=3D xenlight_golang_convert_to_C(nf, outer_name=3Df.= 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 =3D None, outer_name =3D 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 fie= ld + named outer_name. + """ + s =3D '' + + gotypename =3D xenlight_golang_fmt_name(ty.type.typename) + ctypename =3D ty.type.typename + goname =3D xenlight_golang_fmt_name(ty.name) + cname =3D 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 =3D '_' + cname + + # If outer_name is set, treat this as nested. + if outer_name is not None: + goname =3D '{}.{}'.format(xenlight_golang_fmt_name(outer_name), go= name) + cname =3D '{}.{}'.format(outer_name, cname) + + is_castable =3D (ty.type.json_parse_type =3D=3D 'JSON_INTEGER' or + isinstance(ty.type, idl.Enumeration) or + gotypename in go_builtin_types) + + if not is_castable: + s +=3D 'if err :=3D x.{}.toC(&xc.{}); err !=3D nil {{\n'.format(go= name,cname) + s +=3D 'return err\n}\n' + + elif gotypename =3D=3D 'string': + # Use the cgo helper for converting C strings. + s +=3D 'if x.{} !=3D "" {{\n'.format(goname) + s +=3D 'xc.{} =3D C.CString(x.{})}}\n'.format(cname,goname) + + else: + s +=3D 'xc.{} =3D C.{}(x.{})\n'.format(cname,ctypename,goname) + + return s + def xenlight_golang_fmt_name(name, exported =3D True): """ Take a given type name and return an diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/h= elpers.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) er= ror { return nil } =20 +func (x *IoportRange) toC(xc *C.libxl_ioport_range) (err error) { + defer func() { + if err !=3D nil { + C.libxl_ioport_range_dispose(xc) + } + }() + + xc.first =3D C.uint32_t(x.First) + xc.number =3D C.uint32_t(x.Number) + + return nil +} + func (x *IomemRange) fromC(xc *C.libxl_iomem_range) error { x.Start =3D uint64(xc.start) x.Number =3D uint64(xc.number) @@ -45,12 +58,38 @@ func (x *IomemRange) fromC(xc *C.libxl_iomem_range) err= or { return nil } =20 +func (x *IomemRange) toC(xc *C.libxl_iomem_range) (err error) { + defer func() { + if err !=3D nil { + C.libxl_iomem_range_dispose(xc) + } + }() + + xc.start =3D C.uint64_t(x.Start) + xc.number =3D C.uint64_t(x.Number) + xc.gfn =3D C.uint64_t(x.Gfn) + + return nil +} + func (x *VgaInterfaceInfo) fromC(xc *C.libxl_vga_interface_info) error { x.Kind =3D VgaInterfaceType(xc.kind) =20 return nil } =20 +func (x *VgaInterfaceInfo) toC(xc *C.libxl_vga_interface_info) (err error)= { + defer func() { + if err !=3D nil { + C.libxl_vga_interface_info_dispose(xc) + } + }() + + xc.kind =3D C.libxl_vga_interface_type(x.Kind) + + return nil +} + func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error { if err :=3D x.Enable.fromC(&xc.enable); err !=3D nil { return err @@ -65,6 +104,30 @@ func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error { return nil } =20 +func (x *VncInfo) toC(xc *C.libxl_vnc_info) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vnc_info_dispose(xc) + } + }() + + if err :=3D x.Enable.toC(&xc.enable); err !=3D nil { + return err + } + if x.Listen !=3D "" { + xc.listen =3D C.CString(x.Listen) + } + if x.Passwd !=3D "" { + xc.passwd =3D C.CString(x.Passwd) + } + xc.display =3D C.int(x.Display) + if err :=3D x.Findunused.toC(&xc.findunused); err !=3D nil { + return err + } + + return nil +} + func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error { if err :=3D x.Enable.fromC(&xc.enable); err !=3D nil { return err @@ -92,6 +155,47 @@ func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error= { return nil } =20 +func (x *SpiceInfo) toC(xc *C.libxl_spice_info) (err error) { + defer func() { + if err !=3D nil { + C.libxl_spice_info_dispose(xc) + } + }() + + if err :=3D x.Enable.toC(&xc.enable); err !=3D nil { + return err + } + xc.port =3D C.int(x.Port) + xc.tls_port =3D C.int(x.TlsPort) + if x.Host !=3D "" { + xc.host =3D C.CString(x.Host) + } + if err :=3D x.DisableTicketing.toC(&xc.disable_ticketing); err !=3D nil { + return err + } + if x.Passwd !=3D "" { + xc.passwd =3D C.CString(x.Passwd) + } + if err :=3D x.AgentMouse.toC(&xc.agent_mouse); err !=3D nil { + return err + } + if err :=3D x.Vdagent.toC(&xc.vdagent); err !=3D nil { + return err + } + if err :=3D x.ClipboardSharing.toC(&xc.clipboard_sharing); err !=3D nil { + return err + } + xc.usbredirection =3D C.int(x.Usbredirection) + if x.ImageCompression !=3D "" { + xc.image_compression =3D C.CString(x.ImageCompression) + } + if x.StreamingVideo !=3D "" { + xc.streaming_video =3D C.CString(x.StreamingVideo) + } + + return nil +} + func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error { if err :=3D x.Enable.fromC(&xc.enable); err !=3D nil { return err @@ -105,6 +209,29 @@ func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error { return nil } =20 +func (x *SdlInfo) toC(xc *C.libxl_sdl_info) (err error) { + defer func() { + if err !=3D nil { + C.libxl_sdl_info_dispose(xc) + } + }() + + if err :=3D x.Enable.toC(&xc.enable); err !=3D nil { + return err + } + if err :=3D x.Opengl.toC(&xc.opengl); err !=3D nil { + return err + } + if x.Display !=3D "" { + xc.display =3D C.CString(x.Display) + } + if x.Xauthority !=3D "" { + xc.xauthority =3D C.CString(x.Xauthority) + } + + return nil +} + func (x *Dominfo) fromC(xc *C.libxl_dominfo) error { if err :=3D x.Uuid.fromC(&xc.uuid); err !=3D nil { return err @@ -133,6 +260,42 @@ func (x *Dominfo) fromC(xc *C.libxl_dominfo) error { return nil } =20 +func (x *Dominfo) toC(xc *C.libxl_dominfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_dominfo_dispose(xc) + } + }() + + if err :=3D x.Uuid.toC(&xc.uuid); err !=3D nil { + return err + } + xc.domid =3D C.libxl_domid(x.Domid) + xc.ssidref =3D C.uint32_t(x.Ssidref) + if x.SsidLabel !=3D "" { + xc.ssid_label =3D C.CString(x.SsidLabel) + } + xc.running =3D C.bool(x.Running) + xc.blocked =3D C.bool(x.Blocked) + xc.paused =3D C.bool(x.Paused) + xc.shutdown =3D C.bool(x.Shutdown) + xc.dying =3D C.bool(x.Dying) + xc.never_stop =3D C.bool(x.NeverStop) + xc.shutdown_reason =3D C.libxl_shutdown_reason(x.ShutdownReason) + xc.outstanding_memkb =3D C.uint64_t(x.OutstandingMemkb) + xc.current_memkb =3D C.uint64_t(x.CurrentMemkb) + xc.shared_memkb =3D C.uint64_t(x.SharedMemkb) + xc.paged_memkb =3D C.uint64_t(x.PagedMemkb) + xc.max_memkb =3D C.uint64_t(x.MaxMemkb) + xc.cpu_time =3D C.uint64_t(x.CpuTime) + xc.vcpu_max_id =3D C.uint32_t(x.VcpuMaxId) + xc.vcpu_online =3D C.uint32_t(x.VcpuOnline) + xc.cpupool =3D C.uint32_t(x.Cpupool) + xc.domain_type =3D C.libxl_domain_type(x.DomainType) + + return nil +} + func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) error { x.Poolid =3D uint32(xc.poolid) x.PoolName =3D C.GoString(xc.pool_name) @@ -145,6 +308,26 @@ func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) e= rror { return nil } =20 +func (x *Cpupoolinfo) toC(xc *C.libxl_cpupoolinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_cpupoolinfo_dispose(xc) + } + }() + + xc.poolid =3D C.uint32_t(x.Poolid) + if x.PoolName !=3D "" { + xc.pool_name =3D C.CString(x.PoolName) + } + xc.sched =3D C.libxl_scheduler(x.Sched) + xc.n_dom =3D C.uint32_t(x.NDom) + if err :=3D x.Cpumap.toC(&xc.cpumap); err !=3D nil { + return err + } + + return nil +} + func (x *Channelinfo) fromC(xc *C.libxl_channelinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -179,6 +362,29 @@ func (x *ChannelinfoConnectionUnionPty) fromC(xc *C.li= bxl_channelinfo) error { return nil } =20 +func (x *Channelinfo) toC(xc *C.libxl_channelinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_channelinfo_dispose(xc) + } + }() + + if x.Backend !=3D "" { + xc.backend =3D C.CString(x.Backend) + } + xc.backend_id =3D C.uint32_t(x.BackendId) + if x.Frontend !=3D "" { + xc.frontend =3D C.CString(x.Frontend) + } + xc.frontend_id =3D C.uint32_t(x.FrontendId) + xc.devid =3D C.libxl_devid(x.Devid) + xc.state =3D C.int(x.State) + xc.evtch =3D C.int(x.Evtch) + xc.rref =3D C.int(x.Rref) + + return nil +} + func (x *Vminfo) fromC(xc *C.libxl_vminfo) error { if err :=3D x.Uuid.fromC(&xc.uuid); err !=3D nil { return err @@ -188,6 +394,21 @@ func (x *Vminfo) fromC(xc *C.libxl_vminfo) error { return nil } =20 +func (x *Vminfo) toC(xc *C.libxl_vminfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vminfo_dispose(xc) + } + }() + + if err :=3D x.Uuid.toC(&xc.uuid); err !=3D nil { + return err + } + xc.domid =3D C.libxl_domid(x.Domid) + + return nil +} + func (x *VersionInfo) fromC(xc *C.libxl_version_info) error { x.XenVersionMajor =3D int(xc.xen_version_major) x.XenVersionMinor =3D int(xc.xen_version_minor) @@ -206,6 +427,48 @@ func (x *VersionInfo) fromC(xc *C.libxl_version_info) = error { return nil } =20 +func (x *VersionInfo) toC(xc *C.libxl_version_info) (err error) { + defer func() { + if err !=3D nil { + C.libxl_version_info_dispose(xc) + } + }() + + xc.xen_version_major =3D C.int(x.XenVersionMajor) + xc.xen_version_minor =3D C.int(x.XenVersionMinor) + if x.XenVersionExtra !=3D "" { + xc.xen_version_extra =3D C.CString(x.XenVersionExtra) + } + if x.Compiler !=3D "" { + xc.compiler =3D C.CString(x.Compiler) + } + if x.CompileBy !=3D "" { + xc.compile_by =3D C.CString(x.CompileBy) + } + if x.CompileDomain !=3D "" { + xc.compile_domain =3D C.CString(x.CompileDomain) + } + if x.CompileDate !=3D "" { + xc.compile_date =3D C.CString(x.CompileDate) + } + if x.Capabilities !=3D "" { + xc.capabilities =3D C.CString(x.Capabilities) + } + if x.Changeset !=3D "" { + xc.changeset =3D C.CString(x.Changeset) + } + xc.virt_start =3D C.uint64_t(x.VirtStart) + xc.pagesize =3D C.int(x.Pagesize) + if x.Commandline !=3D "" { + xc.commandline =3D C.CString(x.Commandline) + } + if x.BuildId !=3D "" { + xc.build_id =3D C.CString(x.BuildId) + } + + return nil +} + func (x *DomainCreateInfo) fromC(xc *C.libxl_domain_create_info) error { x.Type =3D DomainType(xc._type) if err :=3D x.Hap.fromC(&xc.hap); err !=3D nil { @@ -239,6 +502,51 @@ func (x *DomainCreateInfo) fromC(xc *C.libxl_domain_cr= eate_info) error { return nil } =20 +func (x *DomainCreateInfo) toC(xc *C.libxl_domain_create_info) (err error)= { + defer func() { + if err !=3D nil { + C.libxl_domain_create_info_dispose(xc) + } + }() + + xc._type =3D C.libxl_domain_type(x.Type) + if err :=3D x.Hap.toC(&xc.hap); err !=3D nil { + return err + } + if err :=3D x.Oos.toC(&xc.oos); err !=3D nil { + return err + } + xc.ssidref =3D C.uint32_t(x.Ssidref) + if x.SsidLabel !=3D "" { + xc.ssid_label =3D C.CString(x.SsidLabel) + } + if x.Name !=3D "" { + xc.name =3D C.CString(x.Name) + } + if err :=3D x.Uuid.toC(&xc.uuid); err !=3D nil { + return err + } + if err :=3D x.Xsdata.toC(&xc.xsdata); err !=3D nil { + return err + } + if err :=3D x.Platformdata.toC(&xc.platformdata); err !=3D nil { + return err + } + xc.poolid =3D C.uint32_t(x.Poolid) + if x.PoolName !=3D "" { + xc.pool_name =3D C.CString(x.PoolName) + } + if err :=3D x.RunHotplugScripts.toC(&xc.run_hotplug_scripts); err !=3D ni= l { + return err + } + if err :=3D x.DriverDomain.toC(&xc.driver_domain); err !=3D nil { + return err + } + xc.passthrough =3D C.libxl_passthrough(x.Passthrough) + + return nil +} + func (x *DomainRestoreParams) fromC(xc *C.libxl_domain_restore_params) err= or { x.CheckpointedStream =3D int(xc.checkpointed_stream) x.StreamVersion =3D uint32(xc.stream_version) @@ -250,6 +558,25 @@ func (x *DomainRestoreParams) fromC(xc *C.libxl_domain= _restore_params) error { return nil } =20 +func (x *DomainRestoreParams) toC(xc *C.libxl_domain_restore_params) (err = error) { + defer func() { + if err !=3D nil { + C.libxl_domain_restore_params_dispose(xc) + } + }() + + xc.checkpointed_stream =3D C.int(x.CheckpointedStream) + xc.stream_version =3D C.uint32_t(x.StreamVersion) + if x.ColoProxyScript !=3D "" { + xc.colo_proxy_script =3D C.CString(x.ColoProxyScript) + } + if err :=3D x.UserspaceColoProxy.toC(&xc.userspace_colo_proxy); err !=3D = nil { + return err + } + + return nil +} + func (x *SchedParams) fromC(xc *C.libxl_sched_params) error { x.Vcpuid =3D int(xc.vcpuid) x.Weight =3D int(xc.weight) @@ -261,6 +588,23 @@ func (x *SchedParams) fromC(xc *C.libxl_sched_params) = error { return nil } =20 +func (x *SchedParams) toC(xc *C.libxl_sched_params) (err error) { + defer func() { + if err !=3D nil { + C.libxl_sched_params_dispose(xc) + } + }() + + xc.vcpuid =3D C.int(x.Vcpuid) + xc.weight =3D C.int(x.Weight) + xc.cap =3D C.int(x.Cap) + xc.period =3D C.int(x.Period) + xc.extratime =3D C.int(x.Extratime) + xc.budget =3D C.int(x.Budget) + + return nil +} + func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error { x.Sched =3D Scheduler(xc.sched) numVcpus :=3D int(xc.num_vcpus) @@ -275,6 +619,18 @@ func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched= _params) error { return nil } =20 +func (x *VcpuSchedParams) toC(xc *C.libxl_vcpu_sched_params) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vcpu_sched_params_dispose(xc) + } + }() + + xc.sched =3D C.libxl_scheduler(x.Sched) + + return nil +} + func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error { x.Sched =3D Scheduler(xc.sched) x.Weight =3D int(xc.weight) @@ -288,6 +644,25 @@ func (x *DomainSchedParams) fromC(xc *C.libxl_domain_s= ched_params) error { return nil } =20 +func (x *DomainSchedParams) toC(xc *C.libxl_domain_sched_params) (err erro= r) { + defer func() { + if err !=3D nil { + C.libxl_domain_sched_params_dispose(xc) + } + }() + + xc.sched =3D C.libxl_scheduler(x.Sched) + xc.weight =3D C.int(x.Weight) + xc.cap =3D C.int(x.Cap) + xc.period =3D C.int(x.Period) + xc.budget =3D C.int(x.Budget) + xc.extratime =3D C.int(x.Extratime) + xc.slice =3D C.int(x.Slice) + xc.latency =3D C.int(x.Latency) + + return nil +} + func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error { x.Memkb =3D uint64(xc.memkb) numDistances :=3D int(xc.num_distances) @@ -304,6 +679,22 @@ func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) erro= r { return nil } =20 +func (x *VnodeInfo) toC(xc *C.libxl_vnode_info) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vnode_info_dispose(xc) + } + }() + + xc.memkb =3D C.uint64_t(x.Memkb) + xc.pnode =3D C.uint32_t(x.Pnode) + if err :=3D x.Vcpus.toC(&xc.vcpus); err !=3D nil { + return err + } + + return nil +} + func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) error { x.Strategy =3D RdmReserveStrategy(xc.strategy) x.Policy =3D RdmReservePolicy(xc.policy) @@ -311,6 +702,19 @@ func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) er= ror { return nil } =20 +func (x *RdmReserve) toC(xc *C.libxl_rdm_reserve) (err error) { + defer func() { + if err !=3D nil { + C.libxl_rdm_reserve_dispose(xc) + } + }() + + xc.strategy =3D C.libxl_rdm_reserve_strategy(x.Strategy) + xc.policy =3D C.libxl_rdm_reserve_policy(x.Policy) + + return nil +} + func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error { x.MaxVcpus =3D int(xc.max_vcpus) if err :=3D x.AvailVcpus.fromC(&xc.avail_vcpus); err !=3D nil { @@ -613,6 +1017,120 @@ func (x *DomainBuildInfoTypeUnionPvh) fromC(xc *C.li= bxl_domain_build_info) error return nil } =20 +func (x *DomainBuildInfo) toC(xc *C.libxl_domain_build_info) (err error) { + defer func() { + if err !=3D nil { + C.libxl_domain_build_info_dispose(xc) + } + }() + + xc.max_vcpus =3D C.int(x.MaxVcpus) + if err :=3D x.AvailVcpus.toC(&xc.avail_vcpus); err !=3D nil { + return err + } + if err :=3D x.Cpumap.toC(&xc.cpumap); err !=3D nil { + return err + } + if err :=3D x.Nodemap.toC(&xc.nodemap); err !=3D nil { + return err + } + if err :=3D x.NumaPlacement.toC(&xc.numa_placement); err !=3D nil { + return err + } + xc.tsc_mode =3D C.libxl_tsc_mode(x.TscMode) + xc.max_memkb =3D C.uint64_t(x.MaxMemkb) + xc.target_memkb =3D C.uint64_t(x.TargetMemkb) + xc.video_memkb =3D C.uint64_t(x.VideoMemkb) + xc.shadow_memkb =3D C.uint64_t(x.ShadowMemkb) + xc.iommu_memkb =3D C.uint64_t(x.IommuMemkb) + xc.rtc_timeoffset =3D C.uint32_t(x.RtcTimeoffset) + xc.exec_ssidref =3D C.uint32_t(x.ExecSsidref) + if x.ExecSsidLabel !=3D "" { + xc.exec_ssid_label =3D C.CString(x.ExecSsidLabel) + } + if err :=3D x.Localtime.toC(&xc.localtime); err !=3D nil { + return err + } + if err :=3D x.DisableMigrate.toC(&xc.disable_migrate); err !=3D nil { + return err + } + if err :=3D x.Cpuid.toC(&xc.cpuid); err !=3D nil { + return err + } + if x.BlkdevStart !=3D "" { + xc.blkdev_start =3D C.CString(x.BlkdevStart) + } + xc.max_grant_frames =3D C.uint32_t(x.MaxGrantFrames) + xc.max_maptrack_frames =3D C.uint32_t(x.MaxMaptrackFrames) + xc.device_model_version =3D C.libxl_device_model_version(x.DeviceModelVer= sion) + if err :=3D x.DeviceModelStubdomain.toC(&xc.device_model_stubdomain); err= !=3D nil { + return err + } + if x.DeviceModel !=3D "" { + xc.device_model =3D C.CString(x.DeviceModel) + } + xc.device_model_ssidref =3D C.uint32_t(x.DeviceModelSsidref) + if x.DeviceModelSsidLabel !=3D "" { + xc.device_model_ssid_label =3D C.CString(x.DeviceModelSsidLabel) + } + if x.DeviceModelUser !=3D "" { + xc.device_model_user =3D C.CString(x.DeviceModelUser) + } + if err :=3D x.Extra.toC(&xc.extra); err !=3D nil { + return err + } + if err :=3D x.ExtraPv.toC(&xc.extra_pv); err !=3D nil { + return err + } + if err :=3D x.ExtraHvm.toC(&xc.extra_hvm); err !=3D nil { + return err + } + if err :=3D x.SchedParams.toC(&xc.sched_params); err !=3D nil { + return err + } + if err :=3D x.ClaimMode.toC(&xc.claim_mode); err !=3D nil { + return err + } + xc.event_channels =3D C.uint32_t(x.EventChannels) + if x.Kernel !=3D "" { + xc.kernel =3D C.CString(x.Kernel) + } + if x.Cmdline !=3D "" { + xc.cmdline =3D C.CString(x.Cmdline) + } + if x.Ramdisk !=3D "" { + xc.ramdisk =3D C.CString(x.Ramdisk) + } + if x.DeviceTree !=3D "" { + xc.device_tree =3D C.CString(x.DeviceTree) + } + if err :=3D x.Acpi.toC(&xc.acpi); err !=3D nil { + return err + } + if x.Bootloader !=3D "" { + xc.bootloader =3D C.CString(x.Bootloader) + } + if err :=3D x.BootloaderArgs.toC(&xc.bootloader_args); err !=3D nil { + return err + } + xc.timer_mode =3D C.libxl_timer_mode(x.TimerMode) + if err :=3D x.NestedHvm.toC(&xc.nested_hvm); err !=3D nil { + return err + } + if err :=3D x.Apic.toC(&xc.apic); err !=3D nil { + return err + } + if err :=3D x.DmRestrict.toC(&xc.dm_restrict); err !=3D nil { + return err + } + xc.tee =3D C.libxl_tee_type(x.Tee) + xc.arch_arm.gic_version =3D C.libxl_gic_version(x.ArchArm.GicVersion) + xc.arch_arm.vuart =3D C.libxl_vuart_type(x.ArchArm.Vuart) + xc.altp2m =3D C.libxl_altp2m_mode(x.Altp2M) + + return nil +} + func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -628,6 +1146,31 @@ func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) err= or { return nil } =20 +func (x *DeviceVfb) toC(xc *C.libxl_device_vfb) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_vfb_dispose(xc) + } + }() + + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + xc.devid =3D C.libxl_devid(x.Devid) + if err :=3D x.Vnc.toC(&xc.vnc); err !=3D nil { + return err + } + if err :=3D x.Sdl.toC(&xc.sdl); err !=3D nil { + return err + } + if x.Keymap !=3D "" { + xc.keymap =3D C.CString(x.Keymap) + } + + return nil +} + func (x *DeviceVkb) fromC(xc *C.libxl_device_vkb) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -648,6 +1191,36 @@ func (x *DeviceVkb) fromC(xc *C.libxl_device_vkb) err= or { return nil } =20 +func (x *DeviceVkb) toC(xc *C.libxl_device_vkb) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_vkb_dispose(xc) + } + }() + + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + xc.devid =3D C.libxl_devid(x.Devid) + xc.backend_type =3D C.libxl_vkb_backend(x.BackendType) + if x.UniqueId !=3D "" { + xc.unique_id =3D C.CString(x.UniqueId) + } + xc.feature_disable_keyboard =3D C.bool(x.FeatureDisableKeyboard) + xc.feature_disable_pointer =3D C.bool(x.FeatureDisablePointer) + xc.feature_abs_pointer =3D C.bool(x.FeatureAbsPointer) + xc.feature_raw_pointer =3D C.bool(x.FeatureRawPointer) + xc.feature_multi_touch =3D C.bool(x.FeatureMultiTouch) + xc.width =3D C.uint32_t(x.Width) + xc.height =3D C.uint32_t(x.Height) + xc.multi_touch_width =3D C.uint32_t(x.MultiTouchWidth) + xc.multi_touch_height =3D C.uint32_t(x.MultiTouchHeight) + xc.multi_touch_num_contacts =3D C.uint32_t(x.MultiTouchNumContacts) + + return nil +} + func (x *DeviceDisk) fromC(xc *C.libxl_device_disk) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -678,6 +1251,58 @@ func (x *DeviceDisk) fromC(xc *C.libxl_device_disk) e= rror { return nil } =20 +func (x *DeviceDisk) toC(xc *C.libxl_device_disk) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_disk_dispose(xc) + } + }() + + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + if x.PdevPath !=3D "" { + xc.pdev_path =3D C.CString(x.PdevPath) + } + if x.Vdev !=3D "" { + xc.vdev =3D C.CString(x.Vdev) + } + xc.backend =3D C.libxl_disk_backend(x.Backend) + xc.format =3D C.libxl_disk_format(x.Format) + if x.Script !=3D "" { + xc.script =3D C.CString(x.Script) + } + xc.removable =3D C.int(x.Removable) + xc.readwrite =3D C.int(x.Readwrite) + xc.is_cdrom =3D C.int(x.IsCdrom) + xc.direct_io_safe =3D C.bool(x.DirectIoSafe) + if err :=3D x.DiscardEnable.toC(&xc.discard_enable); err !=3D nil { + return err + } + if err :=3D x.ColoEnable.toC(&xc.colo_enable); err !=3D nil { + return err + } + if err :=3D x.ColoRestoreEnable.toC(&xc.colo_restore_enable); err !=3D ni= l { + return err + } + if x.ColoHost !=3D "" { + xc.colo_host =3D C.CString(x.ColoHost) + } + xc.colo_port =3D C.int(x.ColoPort) + if x.ColoExport !=3D "" { + xc.colo_export =3D C.CString(x.ColoExport) + } + if x.ActiveDisk !=3D "" { + xc.active_disk =3D C.CString(x.ActiveDisk) + } + if x.HiddenDisk !=3D "" { + xc.hidden_disk =3D C.CString(x.HiddenDisk) + } + + return nil +} + func (x *DeviceNic) fromC(xc *C.libxl_device_nic) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -748,6 +1373,194 @@ func (x *DeviceNic) fromC(xc *C.libxl_device_nic) er= ror { return nil } =20 +func (x *DeviceNic) toC(xc *C.libxl_device_nic) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_nic_dispose(xc) + } + }() + + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + xc.devid =3D C.libxl_devid(x.Devid) + xc.mtu =3D C.int(x.Mtu) + if x.Model !=3D "" { + xc.model =3D C.CString(x.Model) + } + if err :=3D x.Mac.toC(&xc.mac); err !=3D nil { + return err + } + if x.Ip !=3D "" { + xc.ip =3D C.CString(x.Ip) + } + if x.Bridge !=3D "" { + xc.bridge =3D C.CString(x.Bridge) + } + if x.Ifname !=3D "" { + xc.ifname =3D C.CString(x.Ifname) + } + if x.Script !=3D "" { + xc.script =3D C.CString(x.Script) + } + xc.nictype =3D C.libxl_nic_type(x.Nictype) + xc.rate_bytes_per_interval =3D C.uint64_t(x.RateBytesPerInterval) + xc.rate_interval_usecs =3D C.uint32_t(x.RateIntervalUsecs) + if x.Gatewaydev !=3D "" { + xc.gatewaydev =3D C.CString(x.Gatewaydev) + } + if x.ColoftForwarddev !=3D "" { + xc.coloft_forwarddev =3D C.CString(x.ColoftForwarddev) + } + if x.ColoSockMirrorId !=3D "" { + xc.colo_sock_mirror_id =3D C.CString(x.ColoSockMirrorId) + } + if x.ColoSockMirrorIp !=3D "" { + xc.colo_sock_mirror_ip =3D C.CString(x.ColoSockMirrorIp) + } + if x.ColoSockMirrorPort !=3D "" { + xc.colo_sock_mirror_port =3D C.CString(x.ColoSockMirrorPort) + } + if x.ColoSockComparePriInId !=3D "" { + xc.colo_sock_compare_pri_in_id =3D C.CString(x.ColoSockComparePriInId) + } + if x.ColoSockComparePriInIp !=3D "" { + xc.colo_sock_compare_pri_in_ip =3D C.CString(x.ColoSockComparePriInIp) + } + if x.ColoSockComparePriInPort !=3D "" { + xc.colo_sock_compare_pri_in_port =3D C.CString(x.ColoSockComparePriInPor= t) + } + if x.ColoSockCompareSecInId !=3D "" { + xc.colo_sock_compare_sec_in_id =3D C.CString(x.ColoSockCompareSecInId) + } + if x.ColoSockCompareSecInIp !=3D "" { + xc.colo_sock_compare_sec_in_ip =3D C.CString(x.ColoSockCompareSecInIp) + } + if x.ColoSockCompareSecInPort !=3D "" { + xc.colo_sock_compare_sec_in_port =3D C.CString(x.ColoSockCompareSecInPor= t) + } + if x.ColoSockCompareNotifyId !=3D "" { + xc.colo_sock_compare_notify_id =3D C.CString(x.ColoSockCompareNotifyId) + } + if x.ColoSockCompareNotifyIp !=3D "" { + xc.colo_sock_compare_notify_ip =3D C.CString(x.ColoSockCompareNotifyIp) + } + if x.ColoSockCompareNotifyPort !=3D "" { + xc.colo_sock_compare_notify_port =3D C.CString(x.ColoSockCompareNotifyPo= rt) + } + if x.ColoSockRedirector0Id !=3D "" { + xc.colo_sock_redirector0_id =3D C.CString(x.ColoSockRedirector0Id) + } + if x.ColoSockRedirector0Ip !=3D "" { + xc.colo_sock_redirector0_ip =3D C.CString(x.ColoSockRedirector0Ip) + } + if x.ColoSockRedirector0Port !=3D "" { + xc.colo_sock_redirector0_port =3D C.CString(x.ColoSockRedirector0Port) + } + if x.ColoSockRedirector1Id !=3D "" { + xc.colo_sock_redirector1_id =3D C.CString(x.ColoSockRedirector1Id) + } + if x.ColoSockRedirector1Ip !=3D "" { + xc.colo_sock_redirector1_ip =3D C.CString(x.ColoSockRedirector1Ip) + } + if x.ColoSockRedirector1Port !=3D "" { + xc.colo_sock_redirector1_port =3D C.CString(x.ColoSockRedirector1Port) + } + if x.ColoSockRedirector2Id !=3D "" { + xc.colo_sock_redirector2_id =3D C.CString(x.ColoSockRedirector2Id) + } + if x.ColoSockRedirector2Ip !=3D "" { + xc.colo_sock_redirector2_ip =3D C.CString(x.ColoSockRedirector2Ip) + } + if x.ColoSockRedirector2Port !=3D "" { + xc.colo_sock_redirector2_port =3D C.CString(x.ColoSockRedirector2Port) + } + if x.ColoFilterMirrorQueue !=3D "" { + xc.colo_filter_mirror_queue =3D C.CString(x.ColoFilterMirrorQueue) + } + if x.ColoFilterMirrorOutdev !=3D "" { + xc.colo_filter_mirror_outdev =3D C.CString(x.ColoFilterMirrorOutdev) + } + if x.ColoFilterRedirector0Queue !=3D "" { + xc.colo_filter_redirector0_queue =3D C.CString(x.ColoFilterRedirector0Qu= eue) + } + if x.ColoFilterRedirector0Indev !=3D "" { + xc.colo_filter_redirector0_indev =3D C.CString(x.ColoFilterRedirector0In= dev) + } + if x.ColoFilterRedirector0Outdev !=3D "" { + xc.colo_filter_redirector0_outdev =3D C.CString(x.ColoFilterRedirector0O= utdev) + } + if x.ColoFilterRedirector1Queue !=3D "" { + xc.colo_filter_redirector1_queue =3D C.CString(x.ColoFilterRedirector1Qu= eue) + } + if x.ColoFilterRedirector1Indev !=3D "" { + xc.colo_filter_redirector1_indev =3D C.CString(x.ColoFilterRedirector1In= dev) + } + if x.ColoFilterRedirector1Outdev !=3D "" { + xc.colo_filter_redirector1_outdev =3D C.CString(x.ColoFilterRedirector1O= utdev) + } + if x.ColoComparePriIn !=3D "" { + xc.colo_compare_pri_in =3D C.CString(x.ColoComparePriIn) + } + if x.ColoCompareSecIn !=3D "" { + xc.colo_compare_sec_in =3D C.CString(x.ColoCompareSecIn) + } + if x.ColoCompareOut !=3D "" { + xc.colo_compare_out =3D C.CString(x.ColoCompareOut) + } + if x.ColoCompareNotifyDev !=3D "" { + xc.colo_compare_notify_dev =3D C.CString(x.ColoCompareNotifyDev) + } + if x.ColoSockSecRedirector0Id !=3D "" { + xc.colo_sock_sec_redirector0_id =3D C.CString(x.ColoSockSecRedirector0Id) + } + if x.ColoSockSecRedirector0Ip !=3D "" { + xc.colo_sock_sec_redirector0_ip =3D C.CString(x.ColoSockSecRedirector0Ip) + } + if x.ColoSockSecRedirector0Port !=3D "" { + xc.colo_sock_sec_redirector0_port =3D C.CString(x.ColoSockSecRedirector0= Port) + } + if x.ColoSockSecRedirector1Id !=3D "" { + xc.colo_sock_sec_redirector1_id =3D C.CString(x.ColoSockSecRedirector1Id) + } + if x.ColoSockSecRedirector1Ip !=3D "" { + xc.colo_sock_sec_redirector1_ip =3D C.CString(x.ColoSockSecRedirector1Ip) + } + if x.ColoSockSecRedirector1Port !=3D "" { + xc.colo_sock_sec_redirector1_port =3D C.CString(x.ColoSockSecRedirector1= Port) + } + if x.ColoFilterSecRedirector0Queue !=3D "" { + xc.colo_filter_sec_redirector0_queue =3D C.CString(x.ColoFilterSecRedire= ctor0Queue) + } + if x.ColoFilterSecRedirector0Indev !=3D "" { + xc.colo_filter_sec_redirector0_indev =3D C.CString(x.ColoFilterSecRedire= ctor0Indev) + } + if x.ColoFilterSecRedirector0Outdev !=3D "" { + xc.colo_filter_sec_redirector0_outdev =3D C.CString(x.ColoFilterSecRedir= ector0Outdev) + } + if x.ColoFilterSecRedirector1Queue !=3D "" { + xc.colo_filter_sec_redirector1_queue =3D C.CString(x.ColoFilterSecRedire= ctor1Queue) + } + if x.ColoFilterSecRedirector1Indev !=3D "" { + xc.colo_filter_sec_redirector1_indev =3D C.CString(x.ColoFilterSecRedire= ctor1Indev) + } + if x.ColoFilterSecRedirector1Outdev !=3D "" { + xc.colo_filter_sec_redirector1_outdev =3D C.CString(x.ColoFilterSecRedir= ector1Outdev) + } + if x.ColoFilterSecRewriter0Queue !=3D "" { + xc.colo_filter_sec_rewriter0_queue =3D C.CString(x.ColoFilterSecRewriter= 0Queue) + } + if x.ColoCheckpointHost !=3D "" { + xc.colo_checkpoint_host =3D C.CString(x.ColoCheckpointHost) + } + if x.ColoCheckpointPort !=3D "" { + xc.colo_checkpoint_port =3D C.CString(x.ColoCheckpointPort) + } + + return nil +} + func (x *DevicePci) fromC(xc *C.libxl_device_pci) error { x.Func =3D byte(xc._func) x.Dev =3D byte(xc.dev) @@ -764,6 +1577,28 @@ func (x *DevicePci) fromC(xc *C.libxl_device_pci) err= or { return nil } =20 +func (x *DevicePci) toC(xc *C.libxl_device_pci) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_pci_dispose(xc) + } + }() + + xc._func =3D C.uint8_t(x.Func) + xc.dev =3D C.uint8_t(x.Dev) + xc.bus =3D C.uint8_t(x.Bus) + xc.domain =3D C.int(x.Domain) + xc.vdevfn =3D C.uint32_t(x.Vdevfn) + xc.vfunc_mask =3D C.uint32_t(x.VfuncMask) + xc.msitranslate =3D C.bool(x.Msitranslate) + xc.power_mgmt =3D C.bool(x.PowerMgmt) + xc.permissive =3D C.bool(x.Permissive) + xc.seize =3D C.bool(x.Seize) + xc.rdm_policy =3D C.libxl_rdm_reserve_policy(x.RdmPolicy) + + return nil +} + func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) error { x.Start =3D uint64(xc.start) x.Size =3D uint64(xc.size) @@ -772,6 +1607,20 @@ func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) err= or { return nil } =20 +func (x *DeviceRdm) toC(xc *C.libxl_device_rdm) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_rdm_dispose(xc) + } + }() + + xc.start =3D C.uint64_t(x.Start) + xc.size =3D C.uint64_t(x.Size) + xc.policy =3D C.libxl_rdm_reserve_policy(x.Policy) + + return nil +} + func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error { x.Type =3D UsbctrlType(xc._type) x.Devid =3D Devid(xc.devid) @@ -783,6 +1632,25 @@ func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbc= trl) error { return nil } =20 +func (x *DeviceUsbctrl) toC(xc *C.libxl_device_usbctrl) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_usbctrl_dispose(xc) + } + }() + + xc._type =3D C.libxl_usbctrl_type(x.Type) + xc.devid =3D C.libxl_devid(x.Devid) + xc.version =3D C.int(x.Version) + xc.ports =3D C.int(x.Ports) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + + return nil +} + func (x *DeviceUsbdev) fromC(xc *C.libxl_device_usbdev) error { x.Ctrl =3D Devid(xc.ctrl) x.Port =3D int(xc.port) @@ -812,12 +1680,39 @@ func (x *DeviceUsbdevTypeUnionHostdev) fromC(xc *C.l= ibxl_device_usbdev) error { return nil } =20 +func (x *DeviceUsbdev) toC(xc *C.libxl_device_usbdev) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_usbdev_dispose(xc) + } + }() + + xc.ctrl =3D C.libxl_devid(x.Ctrl) + xc.port =3D C.int(x.Port) + + return nil +} + func (x *DeviceDtdev) fromC(xc *C.libxl_device_dtdev) error { x.Path =3D C.GoString(xc.path) =20 return nil } =20 +func (x *DeviceDtdev) toC(xc *C.libxl_device_dtdev) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_dtdev_dispose(xc) + } + }() + + if x.Path !=3D "" { + xc.path =3D C.CString(x.Path) + } + + return nil +} + func (x *DeviceVtpm) fromC(xc *C.libxl_device_vtpm) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -829,6 +1724,25 @@ func (x *DeviceVtpm) fromC(xc *C.libxl_device_vtpm) e= rror { return nil } =20 +func (x *DeviceVtpm) toC(xc *C.libxl_device_vtpm) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_vtpm_dispose(xc) + } + }() + + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + xc.devid =3D C.libxl_devid(x.Devid) + if err :=3D x.Uuid.toC(&xc.uuid); err !=3D nil { + return err + } + + return nil +} + func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -840,6 +1754,31 @@ func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error= { return nil } =20 +func (x *DeviceP9) toC(xc *C.libxl_device_p9) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_p9_dispose(xc) + } + }() + + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + if x.Tag !=3D "" { + xc.tag =3D C.CString(x.Tag) + } + if x.Path !=3D "" { + xc.path =3D C.CString(x.Path) + } + if x.SecurityModel !=3D "" { + xc.security_model =3D C.CString(x.SecurityModel) + } + xc.devid =3D C.libxl_devid(x.Devid) + + return nil +} + func (x *DevicePvcallsif) fromC(xc *C.libxl_device_pvcallsif) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -848,6 +1787,22 @@ func (x *DevicePvcallsif) fromC(xc *C.libxl_device_pv= callsif) error { return nil } =20 +func (x *DevicePvcallsif) toC(xc *C.libxl_device_pvcallsif) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_pvcallsif_dispose(xc) + } + }() + + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + xc.devid =3D C.libxl_devid(x.Devid) + + return nil +} + func (x *DeviceChannel) fromC(xc *C.libxl_device_channel) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -878,6 +1833,25 @@ func (x *DeviceChannelConnectionUnionSocket) fromC(xc= *C.libxl_device_channel) e return nil } =20 +func (x *DeviceChannel) toC(xc *C.libxl_device_channel) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_channel_dispose(xc) + } + }() + + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + xc.devid =3D C.libxl_devid(x.Devid) + if x.Name !=3D "" { + xc.name =3D C.CString(x.Name) + } + + return nil +} + func (x *ConnectorParam) fromC(xc *C.libxl_connector_param) error { x.UniqueId =3D C.GoString(xc.unique_id) x.Width =3D uint32(xc.width) @@ -886,6 +1860,22 @@ func (x *ConnectorParam) fromC(xc *C.libxl_connector_= param) error { return nil } =20 +func (x *ConnectorParam) toC(xc *C.libxl_connector_param) (err error) { + defer func() { + if err !=3D nil { + C.libxl_connector_param_dispose(xc) + } + }() + + if x.UniqueId !=3D "" { + xc.unique_id =3D C.CString(x.UniqueId) + } + xc.width =3D C.uint32_t(x.Width) + xc.height =3D C.uint32_t(x.Height) + + return nil +} + func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdispl) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -903,6 +1893,23 @@ func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdisp= l) error { return nil } =20 +func (x *DeviceVdispl) toC(xc *C.libxl_device_vdispl) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_vdispl_dispose(xc) + } + }() + + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + xc.devid =3D C.libxl_devid(x.Devid) + xc.be_alloc =3D C.bool(x.BeAlloc) + + return nil +} + func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error { numSampleRates :=3D int(xc.num_sample_rates) cSampleRates :=3D (*[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) e= rror { return nil } =20 +func (x *VsndParams) toC(xc *C.libxl_vsnd_params) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vsnd_params_dispose(xc) + } + }() + + xc.channels_min =3D C.uint32_t(x.ChannelsMin) + xc.channels_max =3D C.uint32_t(x.ChannelsMax) + xc.buffer_size =3D C.uint32_t(x.BufferSize) + + return nil +} + func (x *VsndStream) fromC(xc *C.libxl_vsnd_stream) error { x.UniqueId =3D C.GoString(xc.unique_id) x.Type =3D VsndStreamType(xc._type) @@ -933,6 +1954,24 @@ func (x *VsndStream) fromC(xc *C.libxl_vsnd_stream) e= rror { return nil } =20 +func (x *VsndStream) toC(xc *C.libxl_vsnd_stream) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vsnd_stream_dispose(xc) + } + }() + + if x.UniqueId !=3D "" { + xc.unique_id =3D C.CString(x.UniqueId) + } + xc._type =3D C.libxl_vsnd_stream_type(x.Type) + if err :=3D x.Params.toC(&xc.params); err !=3D nil { + return err + } + + return nil +} + func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error { x.Name =3D C.GoString(xc.name) if err :=3D x.Params.fromC(&xc.params); err !=3D nil { @@ -950,6 +1989,23 @@ func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error { return nil } =20 +func (x *VsndPcm) toC(xc *C.libxl_vsnd_pcm) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vsnd_pcm_dispose(xc) + } + }() + + if x.Name !=3D "" { + xc.name =3D C.CString(x.Name) + } + if err :=3D x.Params.toC(&xc.params); err !=3D nil { + return err + } + + return nil +} + func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -971,6 +2027,31 @@ func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) e= rror { return nil } =20 +func (x *DeviceVsnd) toC(xc *C.libxl_device_vsnd) (err error) { + defer func() { + if err !=3D nil { + C.libxl_device_vsnd_dispose(xc) + } + }() + + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + if x.BackendDomname !=3D "" { + xc.backend_domname =3D C.CString(x.BackendDomname) + } + xc.devid =3D C.libxl_devid(x.Devid) + if x.ShortName !=3D "" { + xc.short_name =3D C.CString(x.ShortName) + } + if x.LongName !=3D "" { + xc.long_name =3D C.CString(x.LongName) + } + if err :=3D x.Params.toC(&xc.params); err !=3D nil { + return err + } + + return nil +} + func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error { if err :=3D x.CInfo.fromC(&xc.c_info); err !=3D nil { return err @@ -1107,6 +2188,28 @@ func (x *DomainConfig) fromC(xc *C.libxl_domain_conf= ig) error { return nil } =20 +func (x *DomainConfig) toC(xc *C.libxl_domain_config) (err error) { + defer func() { + if err !=3D nil { + C.libxl_domain_config_dispose(xc) + } + }() + + if err :=3D x.CInfo.toC(&xc.c_info); err !=3D nil { + return err + } + if err :=3D x.BInfo.toC(&xc.b_info); err !=3D nil { + return err + } + xc.on_poweroff =3D C.libxl_action_on_shutdown(x.OnPoweroff) + xc.on_reboot =3D C.libxl_action_on_shutdown(x.OnReboot) + xc.on_watchdog =3D C.libxl_action_on_shutdown(x.OnWatchdog) + xc.on_crash =3D C.libxl_action_on_shutdown(x.OnCrash) + xc.on_soft_reset =3D C.libxl_action_on_shutdown(x.OnSoftReset) + + return nil +} + func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -1120,6 +2223,29 @@ func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error= { return nil } =20 +func (x *Diskinfo) toC(xc *C.libxl_diskinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_diskinfo_dispose(xc) + } + }() + + if x.Backend !=3D "" { + xc.backend =3D C.CString(x.Backend) + } + xc.backend_id =3D C.uint32_t(x.BackendId) + if x.Frontend !=3D "" { + xc.frontend =3D C.CString(x.Frontend) + } + xc.frontend_id =3D C.uint32_t(x.FrontendId) + xc.devid =3D C.libxl_devid(x.Devid) + xc.state =3D C.int(x.State) + xc.evtch =3D C.int(x.Evtch) + xc.rref =3D C.int(x.Rref) + + return nil +} + func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -1134,6 +2260,30 @@ func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error { return nil } =20 +func (x *Nicinfo) toC(xc *C.libxl_nicinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_nicinfo_dispose(xc) + } + }() + + if x.Backend !=3D "" { + xc.backend =3D C.CString(x.Backend) + } + xc.backend_id =3D C.uint32_t(x.BackendId) + if x.Frontend !=3D "" { + xc.frontend =3D C.CString(x.Frontend) + } + xc.frontend_id =3D C.uint32_t(x.FrontendId) + xc.devid =3D C.libxl_devid(x.Devid) + xc.state =3D C.int(x.State) + xc.evtch =3D C.int(x.Evtch) + xc.rref_tx =3D C.int(x.RrefTx) + xc.rref_rx =3D C.int(x.RrefRx) + + return nil +} + func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -1150,6 +2300,32 @@ func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error= { return nil } =20 +func (x *Vtpminfo) toC(xc *C.libxl_vtpminfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vtpminfo_dispose(xc) + } + }() + + if x.Backend !=3D "" { + xc.backend =3D C.CString(x.Backend) + } + xc.backend_id =3D C.uint32_t(x.BackendId) + if x.Frontend !=3D "" { + xc.frontend =3D C.CString(x.Frontend) + } + xc.frontend_id =3D C.uint32_t(x.FrontendId) + xc.devid =3D C.libxl_devid(x.Devid) + xc.state =3D C.int(x.State) + xc.evtch =3D C.int(x.Evtch) + xc.rref =3D C.int(x.Rref) + if err :=3D x.Uuid.toC(&xc.uuid); err !=3D nil { + return err + } + + return nil +} + func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo) error { x.Type =3D UsbctrlType(xc._type) x.Devid =3D Devid(xc.devid) @@ -1167,6 +2343,33 @@ func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo)= error { return nil } =20 +func (x *Usbctrlinfo) toC(xc *C.libxl_usbctrlinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_usbctrlinfo_dispose(xc) + } + }() + + xc._type =3D C.libxl_usbctrl_type(x.Type) + xc.devid =3D C.libxl_devid(x.Devid) + xc.version =3D C.int(x.Version) + xc.ports =3D C.int(x.Ports) + if x.Backend !=3D "" { + xc.backend =3D C.CString(x.Backend) + } + xc.backend_id =3D C.uint32_t(x.BackendId) + if x.Frontend !=3D "" { + xc.frontend =3D C.CString(x.Frontend) + } + xc.frontend_id =3D C.uint32_t(x.FrontendId) + xc.state =3D C.int(x.State) + xc.evtch =3D C.int(x.Evtch) + xc.ref_urb =3D C.int(x.RefUrb) + xc.ref_conn =3D C.int(x.RefConn) + + return nil +} + func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error { x.Vcpuid =3D uint32(xc.vcpuid) x.Cpu =3D uint32(xc.cpu) @@ -1184,6 +2387,29 @@ func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error= { return nil } =20 +func (x *Vcpuinfo) toC(xc *C.libxl_vcpuinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vcpuinfo_dispose(xc) + } + }() + + xc.vcpuid =3D C.uint32_t(x.Vcpuid) + xc.cpu =3D C.uint32_t(x.Cpu) + xc.online =3D C.bool(x.Online) + xc.blocked =3D C.bool(x.Blocked) + xc.running =3D C.bool(x.Running) + xc.vcpu_time =3D C.uint64_t(x.VcpuTime) + if err :=3D x.Cpumap.toC(&xc.cpumap); err !=3D nil { + return err + } + if err :=3D x.CpumapSoft.toC(&xc.cpumap_soft); err !=3D nil { + return err + } + + return nil +} + func (x *Physinfo) fromC(xc *C.libxl_physinfo) error { x.ThreadsPerCore =3D uint32(xc.threads_per_core) x.CoresPerSocket =3D uint32(xc.cores_per_socket) @@ -1211,6 +2437,39 @@ func (x *Physinfo) fromC(xc *C.libxl_physinfo) error= { return nil } =20 +func (x *Physinfo) toC(xc *C.libxl_physinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_physinfo_dispose(xc) + } + }() + + xc.threads_per_core =3D C.uint32_t(x.ThreadsPerCore) + xc.cores_per_socket =3D C.uint32_t(x.CoresPerSocket) + xc.max_cpu_id =3D C.uint32_t(x.MaxCpuId) + xc.nr_cpus =3D C.uint32_t(x.NrCpus) + xc.cpu_khz =3D C.uint32_t(x.CpuKhz) + xc.total_pages =3D C.uint64_t(x.TotalPages) + xc.free_pages =3D C.uint64_t(x.FreePages) + xc.scrub_pages =3D C.uint64_t(x.ScrubPages) + xc.outstanding_pages =3D C.uint64_t(x.OutstandingPages) + xc.sharing_freed_pages =3D C.uint64_t(x.SharingFreedPages) + xc.sharing_used_frames =3D C.uint64_t(x.SharingUsedFrames) + xc.max_possible_mfn =3D C.uint64_t(x.MaxPossibleMfn) + xc.nr_nodes =3D C.uint32_t(x.NrNodes) + if err :=3D x.HwCap.toC(&xc.hw_cap); err !=3D nil { + return err + } + xc.cap_hvm =3D C.bool(x.CapHvm) + xc.cap_pv =3D C.bool(x.CapPv) + xc.cap_hvm_directio =3D C.bool(x.CapHvmDirectio) + xc.cap_hap =3D C.bool(x.CapHap) + xc.cap_shadow =3D C.bool(x.CapShadow) + xc.cap_iommu_hap_pt_share =3D C.bool(x.CapIommuHapPtShare) + + return nil +} + func (x *Connectorinfo) fromC(xc *C.libxl_connectorinfo) error { x.UniqueId =3D C.GoString(xc.unique_id) x.Width =3D uint32(xc.width) @@ -1223,6 +2482,26 @@ func (x *Connectorinfo) fromC(xc *C.libxl_connectori= nfo) error { return nil } =20 +func (x *Connectorinfo) toC(xc *C.libxl_connectorinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_connectorinfo_dispose(xc) + } + }() + + if x.UniqueId !=3D "" { + xc.unique_id =3D C.CString(x.UniqueId) + } + xc.width =3D C.uint32_t(x.Width) + xc.height =3D C.uint32_t(x.Height) + xc.req_evtch =3D C.int(x.ReqEvtch) + xc.req_rref =3D C.int(x.ReqRref) + xc.evt_evtch =3D C.int(x.EvtEvtch) + xc.evt_rref =3D C.int(x.EvtRref) + + return nil +} + func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -1243,6 +2522,28 @@ func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) e= rror { return nil } =20 +func (x *Vdisplinfo) toC(xc *C.libxl_vdisplinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vdisplinfo_dispose(xc) + } + }() + + if x.Backend !=3D "" { + xc.backend =3D C.CString(x.Backend) + } + xc.backend_id =3D C.uint32_t(x.BackendId) + if x.Frontend !=3D "" { + xc.frontend =3D C.CString(x.Frontend) + } + xc.frontend_id =3D C.uint32_t(x.FrontendId) + xc.devid =3D C.libxl_devid(x.Devid) + xc.state =3D C.int(x.State) + xc.be_alloc =3D C.bool(x.BeAlloc) + + return nil +} + func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error { x.ReqEvtch =3D int(xc.req_evtch) x.ReqRref =3D int(xc.req_rref) @@ -1250,6 +2551,19 @@ func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) e= rror { return nil } =20 +func (x *Streaminfo) toC(xc *C.libxl_streaminfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_streaminfo_dispose(xc) + } + }() + + xc.req_evtch =3D C.int(x.ReqEvtch) + xc.req_rref =3D C.int(x.ReqRref) + + return nil +} + func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error { numVsndStreams :=3D int(xc.num_vsnd_streams) cStreams :=3D (*[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 } =20 +func (x *Pcminfo) toC(xc *C.libxl_pcminfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_pcminfo_dispose(xc) + } + }() + + return nil +} + func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -1282,6 +2606,27 @@ func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error= { return nil } =20 +func (x *Vsndinfo) toC(xc *C.libxl_vsndinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vsndinfo_dispose(xc) + } + }() + + if x.Backend !=3D "" { + xc.backend =3D C.CString(x.Backend) + } + xc.backend_id =3D C.uint32_t(x.BackendId) + if x.Frontend !=3D "" { + xc.frontend =3D C.CString(x.Frontend) + } + xc.frontend_id =3D C.uint32_t(x.FrontendId) + xc.devid =3D C.libxl_devid(x.Devid) + xc.state =3D C.int(x.State) + + return nil +} + func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -1295,6 +2640,29 @@ func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error { return nil } =20 +func (x *Vkbinfo) toC(xc *C.libxl_vkbinfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_vkbinfo_dispose(xc) + } + }() + + if x.Backend !=3D "" { + xc.backend =3D C.CString(x.Backend) + } + xc.backend_id =3D C.uint32_t(x.BackendId) + if x.Frontend !=3D "" { + xc.frontend =3D C.CString(x.Frontend) + } + xc.frontend_id =3D C.uint32_t(x.FrontendId) + xc.devid =3D C.libxl_devid(x.Devid) + xc.state =3D C.int(x.State) + xc.evtch =3D C.int(x.Evtch) + xc.rref =3D C.int(x.Rref) + + return nil +} + func (x *Numainfo) fromC(xc *C.libxl_numainfo) error { x.Size =3D uint64(xc.size) x.Free =3D uint64(xc.free) @@ -1308,6 +2676,19 @@ func (x *Numainfo) fromC(xc *C.libxl_numainfo) error= { return nil } =20 +func (x *Numainfo) toC(xc *C.libxl_numainfo) (err error) { + defer func() { + if err !=3D nil { + C.libxl_numainfo_dispose(xc) + } + }() + + xc.size =3D C.uint64_t(x.Size) + xc.free =3D C.uint64_t(x.Free) + + return nil +} + func (x *Cputopology) fromC(xc *C.libxl_cputopology) error { x.Core =3D uint32(xc.core) x.Socket =3D uint32(xc.socket) @@ -1316,6 +2697,20 @@ func (x *Cputopology) fromC(xc *C.libxl_cputopology)= error { return nil } =20 +func (x *Cputopology) toC(xc *C.libxl_cputopology) (err error) { + defer func() { + if err !=3D nil { + C.libxl_cputopology_dispose(xc) + } + }() + + xc.core =3D C.uint32_t(x.Core) + xc.socket =3D C.uint32_t(x.Socket) + xc.node =3D C.uint32_t(x.Node) + + return nil +} + func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error { x.Seg =3D uint16(xc.seg) x.Bus =3D byte(xc.bus) @@ -1325,6 +2720,21 @@ func (x *Pcitopology) fromC(xc *C.libxl_pcitopology)= error { return nil } =20 +func (x *Pcitopology) toC(xc *C.libxl_pcitopology) (err error) { + defer func() { + if err !=3D nil { + C.libxl_pcitopology_dispose(xc) + } + }() + + xc.seg =3D C.uint16_t(x.Seg) + xc.bus =3D C.uint8_t(x.Bus) + xc.devfn =3D C.uint8_t(x.Devfn) + xc.node =3D C.uint32_t(x.Node) + + return nil +} + func (x *SchedCreditParams) fromC(xc *C.libxl_sched_credit_params) error { x.TsliceMs =3D int(xc.tslice_ms) x.RatelimitUs =3D int(xc.ratelimit_us) @@ -1333,12 +2743,26 @@ func (x *SchedCreditParams) fromC(xc *C.libxl_sched= _credit_params) error { return nil } =20 +func (x *SchedCreditParams) toC(xc *C.libxl_sched_credit_params) (err erro= r) { + xc.tslice_ms =3D C.int(x.TsliceMs) + xc.ratelimit_us =3D C.int(x.RatelimitUs) + xc.vcpu_migr_delay_us =3D C.int(x.VcpuMigrDelayUs) + + return nil +} + func (x *SchedCredit2Params) fromC(xc *C.libxl_sched_credit2_params) error= { x.RatelimitUs =3D int(xc.ratelimit_us) =20 return nil } =20 +func (x *SchedCredit2Params) toC(xc *C.libxl_sched_credit2_params) (err er= ror) { + xc.ratelimit_us =3D C.int(x.RatelimitUs) + + return nil +} + func (x *DomainRemusInfo) fromC(xc *C.libxl_domain_remus_info) error { x.Interval =3D int(xc.interval) if err :=3D x.AllowUnsafe.fromC(&xc.allow_unsafe); err !=3D nil { @@ -1367,6 +2791,42 @@ func (x *DomainRemusInfo) fromC(xc *C.libxl_domain_r= emus_info) error { return nil } =20 +func (x *DomainRemusInfo) toC(xc *C.libxl_domain_remus_info) (err error) { + defer func() { + if err !=3D nil { + C.libxl_domain_remus_info_dispose(xc) + } + }() + + xc.interval =3D C.int(x.Interval) + if err :=3D x.AllowUnsafe.toC(&xc.allow_unsafe); err !=3D nil { + return err + } + if err :=3D x.Blackhole.toC(&xc.blackhole); err !=3D nil { + return err + } + if err :=3D x.Compression.toC(&xc.compression); err !=3D nil { + return err + } + if err :=3D x.Netbuf.toC(&xc.netbuf); err !=3D nil { + return err + } + if x.Netbufscript !=3D "" { + xc.netbufscript =3D C.CString(x.Netbufscript) + } + if err :=3D x.Diskbuf.toC(&xc.diskbuf); err !=3D nil { + return err + } + if err :=3D x.Colo.toC(&xc.colo); err !=3D nil { + return err + } + if err :=3D x.UserspaceColoProxy.toC(&xc.userspace_colo_proxy); err !=3D = nil { + return err + } + + return nil +} + func (x *Event) fromC(xc *C.libxl_event) error { if err :=3D x.Link.fromC(&xc.link); err !=3D nil { return err @@ -1436,6 +2896,25 @@ func (x *EventTypeUnionOperationComplete) fromC(xc *= C.libxl_event) error { return nil } =20 +func (x *Event) toC(xc *C.libxl_event) (err error) { + defer func() { + if err !=3D nil { + C.libxl_event_dispose(xc) + } + }() + + if err :=3D x.Link.toC(&xc.link); err !=3D nil { + return err + } + xc.domid =3D C.libxl_domid(x.Domid) + if err :=3D x.Domuuid.toC(&xc.domuuid); err !=3D nil { + return err + } + xc.for_user =3D C.uint64_t(x.ForUser) + + return nil +} + func (x *PsrCatInfo) fromC(xc *C.libxl_psr_cat_info) error { x.Id =3D uint32(xc.id) x.CosMax =3D uint32(xc.cos_max) @@ -1445,6 +2924,21 @@ func (x *PsrCatInfo) fromC(xc *C.libxl_psr_cat_info)= error { return nil } =20 +func (x *PsrCatInfo) toC(xc *C.libxl_psr_cat_info) (err error) { + defer func() { + if err !=3D nil { + C.libxl_psr_cat_info_dispose(xc) + } + }() + + xc.id =3D C.uint32_t(x.Id) + xc.cos_max =3D C.uint32_t(x.CosMax) + xc.cbm_len =3D C.uint32_t(x.CbmLen) + xc.cdp_enabled =3D C.bool(x.CdpEnabled) + + return nil +} + func (x *PsrHwInfo) fromC(xc *C.libxl_psr_hw_info) error { x.Id =3D uint32(xc.id) x.Type =3D PsrFeatType(xc._type) @@ -1491,3 +2985,15 @@ func (x *PsrHwInfoTypeUnionMba) fromC(xc *C.libxl_ps= r_hw_info) error { x.Linear =3D bool(tmp.linear) return nil } + +func (x *PsrHwInfo) toC(xc *C.libxl_psr_hw_info) (err error) { + defer func() { + if err !=3D nil { + C.libxl_psr_hw_info_dispose(xc) + } + }() + + xc.id =3D C.uint32_t(x.Id) + + return nil +} diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenl= ight.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 } =20 -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 :=3D range u { - c.uuid[i] =3D C.uint8_t(v) + cu.uuid[i] =3D C.uint8_t(v) } =20 - return c, nil + return nil } =20 // defboolVal represents a defbool value. @@ -232,15 +230,13 @@ func (d *Defbool) fromC(c *C.libxl_defbool) error { return nil } =20 -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, _ :=3D d.Val() - C.libxl_defbool_set(&c, C.bool(val)) + C.libxl_defbool_set(cd, C.bool(val)) } =20 - return c, nil + return nil } =20 // 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 } =20 -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 :=3D range mac { - cmac[i] =3D C.uint8_t(v) + (*cm)[i] =3D C.uint8_t(v) } =20 - return cmac, nil + return nil } =20 // MsVmGenid represents a libxl_ms_vm_genid. @@ -287,14 +281,12 @@ func (mvg *MsVmGenid) fromC(cmvg *C.libxl_ms_vm_genid= ) error { return nil } =20 -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 :=3D range mvg { cmvg.bytes[i] =3D C.uint8_t(v) } =20 - return cmvg, nil + return nil } =20 // 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{} =20 -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 } =20 // CpuidPolicyList represents a libxl_cpuid_policy_list. // @@ -316,20 +308,18 @@ type CpuidPolicyList string =20 func (cpl CpuidPolicyList) fromC(ccpl *C.libxl_cpuid_policy_list) error { = return nil } =20 -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 :=3D C.CString(string(cpl)) defer C.free(unsafe.Pointer(s)) =20 - ret :=3D C.libxl_cpuid_parse_config(&ccpl, s) + ret :=3D C.libxl_cpuid_parse_config(ccpl, s) if ret !=3D 0 { - C.libxl_cpuid_dispose(&ccpl) + C.libxl_cpuid_dispose(ccpl) =20 - return ccpl, Error(-ret) + return Error(-ret) } =20 - return ccpl, nil + return nil } =20 // Hwcap represents a libxl_hwcap. @@ -343,14 +333,12 @@ func (hwcap *Hwcap) fromC(chwcap *C.libxl_hwcap) erro= r { return nil } =20 -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 :=3D range hwcap { - chwcap[i] =3D C.uint32_t(v) + (*chwcap)[i] =3D C.uint32_t(v) } =20 - return chwcap, nil + return nil } =20 // KeyValueList represents a libxl_key_value_list. @@ -360,8 +348,8 @@ func (hwcap *Hwcap) toC() (C.libxl_hwcap, error) { // Go package. type KeyValueList struct{} =20 -func (kvl KeyValueList) fromC(ckvl *C.libxl_key_value_list) error { r= eturn nil } -func (kvl KeyValueList) toC() (ckvl C.libxl_key_value_list, err error) { r= eturn } +func (kvl KeyValueList) fromC(ckvl *C.libxl_key_value_list) error { re= turn nil } +func (kvl KeyValueList) toC(ckvl *C.libxl_key_value_list) (err error) { re= turn } =20 // 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 } =20 -func (sl StringList) toC() (C.libxl_string_list, error) { +func (sl StringList) toC(csl *C.libxl_string_list) error { var char *C.char size :=3D len(sl) - csl :=3D (C.libxl_string_list)(C.malloc(C.ulong(size) * C.ulong(unsafe.Si= zeof(char)))) + *csl =3D (C.libxl_string_list)(C.malloc(C.ulong(size) * C.ulong(unsafe.Si= zeof(char)))) clist :=3D (*[1 << 30]*C.char)(unsafe.Pointer(csl))[:size:size] =20 for i, v :=3D range sl { clist[i] =3D C.CString(v) } =20 - return csl, nil + return nil } =20 // Bitmap represents a libxl_bitmap. @@ -421,9 +409,7 @@ func (bm *Bitmap) fromC(cbm *C.libxl_bitmap) error { return nil } =20 -func (bm *Bitmap) toC() (C.libxl_bitmap, error) { - var cbm C.libxl_bitmap - +func (bm *Bitmap) toC(cbm *C.libxl_bitmap) error { size :=3D len(bm.bitmap) cbm.size =3D C.uint32_t(size) cbm._map =3D (*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) { =20 copy(cs, bm.bitmap) =20 - return cbm, nil + return nil } =20 func (sr ShutdownReason) String() (str string) { @@ -534,8 +520,8 @@ func (Ctx *Context) CpupoolCreate(Name string, Schedule= r Scheduler, Cpumap Bitma var uuid C.libxl_uuid C.libxl_uuid_generate(&uuid) =20 - cbm, err :=3D Cpumap.toC() - if err !=3D nil { + var cbm C.libxl_bitmap + if err =3D Cpumap.toC(&cbm); err !=3D nil { return } defer C.libxl_bitmap_dispose(&cbm) @@ -577,8 +563,8 @@ func (Ctx *Context) CpupoolCpuadd(Poolid uint32, Cpu in= t) (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 :=3D Cpumap.toC() - if err !=3D nil { + var cbm C.libxl_bitmap + if err =3D Cpumap.toC(&cbm); err !=3D 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 :=3D Cpumap.toC() - if err !=3D nil { + var cbm C.libxl_bitmap + if err =3D Cpumap.toC(&cbm); err !=3D nil { return } defer C.libxl_bitmap_dispose(&cbm) --=20 2.17.1 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel From nobody Mon May 6 11:55:13 2024 Delivered-To: importer@patchew.org Received-SPF: none (zohomail.com: 192.237.175.120 is neither permitted nor denied by domain of lists.xenproject.org) client-ip=192.237.175.120; envelope-from=xen-devel-bounces@lists.xenproject.org; helo=lists.xenproject.org; Authentication-Results: mx.zohomail.com; dkim=fail; spf=none (zohomail.com: 192.237.175.120 is neither permitted nor denied by domain of lists.xenproject.org) smtp.mailfrom=xen-devel-bounces@lists.xenproject.org; dmarc=fail(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1578171744; cv=none; d=zohomail.com; s=zohoarc; b=KsOX811SmBwl8qPpOzzgWPgHTn2pVWM3ivQ8ZJKKp6FFETZ4j6vyYzD5WYxCDIH2JaY7BwuQOdZ/1/uosRX3PObRpquVMxJGmAW7iJSm8aaO2j/ibGeVb6K8AcTabDr6kOh7hxw7q5QdiM+5bZfGT8Est7fPJHZUfwRGsj9lBro= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1578171744; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=KdWj73PgeA0GAMNYmMPFIzrhp+Zjf2r55Qt52a2vcPk=; b=mrepUaraib5qoFN5si2j1Yx6aRk01e3nPg4gfX3IDZsXIEB7rNFHXPKqvMErA/Q7/OAhMcmWpdcYriW6QME5IxuHKXUDqPK+ZX8vB3OqsFYbapl3mmeChzN9JFj5376zdG4JAfZtp/dB76uqc007q6fJg9d2R/hSMO5SRpuzG28= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=none (zohomail.com: 192.237.175.120 is neither permitted nor denied by domain of lists.xenproject.org) smtp.mailfrom=xen-devel-bounces@lists.xenproject.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) by mx.zohomail.com with SMTPS id 1578171744324955.8343743269093; Sat, 4 Jan 2020 13:02:24 -0800 (PST) Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1inqY5-0003GM-TV; Sat, 04 Jan 2020 21:01:29 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1inqY4-0003Fv-FA for xen-devel@lists.xenproject.org; Sat, 04 Jan 2020 21:01:28 +0000 Received: from mail-yw1-xc31.google.com (unknown [2607:f8b0:4864:20::c31]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 5be6861e-2f35-11ea-88e7-bc764e2007e4; Sat, 04 Jan 2020 21:01:21 +0000 (UTC) Received: by mail-yw1-xc31.google.com with SMTP id u139so20160307ywf.13 for ; Sat, 04 Jan 2020 13:01:21 -0800 (PST) Received: from four.lan (cpe-67-241-56-252.twcny.res.rr.com. [67.241.56.252]) by smtp.gmail.com with ESMTPSA id r10sm26366714ywr.97.2020.01.04.13.01.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 04 Jan 2020 13:01:19 -0800 (PST) X-Inumbo-ID: 5be6861e-2f35-11ea-88e7-bc764e2007e4 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 :in-reply-to:references; bh=WLNFmL0WSVUZ7z1EzU2LXnJlAFRuH/CV8Dxe1XOC58k=; b=rfFBJm+OJWPj2Uj3kChcTfKPzO9XeLfsRUDyKN3dhnc0Y3sJ8kxWjBHEpNNNmuHjfM hy+R63JY3G35qK/CsBqGBJPdghjK0/VQsnBSI8jDJTTinUZoACtJDcyrf2g5vB6gjoKd Z3pti90WH7g6NZxZpOlq/faGb1klLLFjJwIzeB/d28Q4hM9YyhrMyjjxhGEXF3o8U3HB +YozR//3gEVuESvbTpkIYJe483gfinjwp+FZnzOyS2mUpdDIjZZqPoEpLOrNmlXI8UVR w21MZaI3jazkbLedQnLkdXshx44WJBuTzm+uDCDtuYZHB4W0NR97/Tx2hPOVlErdjiNc GTlg== 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:in-reply-to:references; bh=WLNFmL0WSVUZ7z1EzU2LXnJlAFRuH/CV8Dxe1XOC58k=; b=FF5+oZG4celfjtlQ6y3sxdaOVv2b39aRYetYhys3oG4xEwXiEg4Zs2W8qgo9synXie hlhivk8pMVVFDrnGABUicTaMZmqxwAaw+WyyuphjSRM2GcvKtkcZwrlmsuoTxhxRok5V MZZdD0wRm8r3qwDkmpx0AQxaSbxY8bX49vEruWUn9oLvC5j7FCQy7pz4v0KVMqNjswEL E0JVszbyC9gHxWVM1H7D2192ZJ28et1ZJJr+LyjcQe+IiicvikPSG/5W7QqhL3JTN45b JqXEhtzOngJ8HfNWXMcRfzgjQz86TyU9mu772npOzHAzmhnRdT2WO1pKZ3MklgI5oSsM MA0g== X-Gm-Message-State: APjAAAX+x5zBLxJGNHgFh+VODBOC0sCZHp2ddHeY25frIkF4UoEsmyF+ BhH9/cakZRxJiOeXyXvC7ZYGHost X-Google-Smtp-Source: APXvYqwjMQ7wCqHQYBmqjm39zVXGf4hwqKfN8CKVYxhfYEvnznwL/dI/8sb2FKwIh6eHTGyzw4nYSg== X-Received: by 2002:a81:1744:: with SMTP id 65mr68848146ywx.110.1578171680113; Sat, 04 Jan 2020 13:01:20 -0800 (PST) From: Nick Rosbrook X-Google-Original-From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Sat, 4 Jan 2020 16:00:52 -0500 Message-Id: <52678cf50a54609dc453df47ffb4fa0429c69bbd.1578170151.git.rosbrookn@ainfosec.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Subject: [Xen-devel] [PATCH v5 2/3] golang/xenlight: implement keyed union Go to C 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 , George Dunlap , Wei Liu MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) 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 Reviewed-by: George Dunlap --- 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/ge= ngotypes.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 =3D None, typename= =3D None, nested =3D False): body +=3D xenlight_golang_convert_to_C(nf, outer_name=3Df.= name) =20 elif isinstance(f.type, idl.KeyedUnion): - # TODO - pass + body +=3D xenlight_golang_union_to_C(f.type, f.name, ty.typena= me) =20 else: raise Exception('type {} not supported'.format(f.type)) =20 return func.format(goname, cname, body) =20 -def xenlight_golang_convert_to_C(ty =3D None, outer_name =3D None): +def xenlight_golang_convert_to_C(ty =3D None, outer_name =3D None, + govarname =3D None, cvarname =3D 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 =3D None, outer_na= me =3D None): """ s =3D '' =20 + # Use 'xc' as the name for the C variable unless otherwise specified. + if cvarname is None: + cvarname =3D 'xc' + + # Use 'x' as the name for the Go variable unless otherwise specified. + if govarname is None: + govarname =3D 'x' + gotypename =3D xenlight_golang_fmt_name(ty.type.typename) ctypename =3D ty.type.typename goname =3D xenlight_golang_fmt_name(ty.name) @@ -502,16 +510,73 @@ def xenlight_golang_convert_to_C(ty =3D None, outer_n= ame =3D None): gotypename in go_builtin_types) =20 if not is_castable: - s +=3D 'if err :=3D x.{}.toC(&xc.{}); err !=3D nil {{\n'.format(go= name,cname) + s +=3D 'if err :=3D {}.{}.toC(&{}.{}); err !=3D nil {{\n'.format(g= ovarname,goname, + cvarnam= e,cname) s +=3D 'return err\n}\n' =20 elif gotypename =3D=3D 'string': # Use the cgo helper for converting C strings. - s +=3D 'if x.{} !=3D "" {{\n'.format(goname) - s +=3D 'xc.{} =3D C.CString(x.{})}}\n'.format(cname,goname) + s +=3D 'if {}.{} !=3D "" {{\n'.format(govarname,goname) + s +=3D '{}.{} =3D C.CString({}.{})}}\n'.format(cvarname,cname, + govarname,goname) =20 else: - s +=3D 'xc.{} =3D C.{}(x.{})\n'.format(cname,ctypename,goname) + s +=3D '{}.{} =3D C.{}({}.{})\n'.format(cvarname,cname,ctypename, + govarname,goname) + + return s + +def xenlight_golang_union_to_C(ty =3D None, union_name =3D '', + struct_name =3D ''): + keyname =3D ty.keyvar.name + gokeyname =3D xenlight_golang_fmt_name(keyname) + keytype =3D ty.keyvar.type.typename + gokeytype =3D xenlight_golang_fmt_name(keytype) + + interface_name =3D '{}_{}_union'.format(struct_name, keyname) + interface_name =3D xenlight_golang_fmt_name(interface_name, exported= =3DFalse) + + cgo_keyname =3D keyname + if cgo_keyname in go_keywords: + cgo_keyname =3D '_' + cgo_keyname + + + s =3D 'xc.{} =3D C.{}(x.{})\n'.format(cgo_keyname,keytype,gokeyname) + s +=3D 'switch x.{}{{\n'.format(gokeyname) + + # Create switch statement to determine how to populate the C union. + for f in ty.fields: + key_val =3D '{}_{}'.format(keytype, f.name) + key_val =3D xenlight_golang_fmt_name(key_val) + if f.type is None: + continue + + s +=3D 'case {}:\n'.format(key_val) + cgotype =3D '{}_{}_union_{}'.format(struct_name,keyname,f.name) + gotype =3D xenlight_golang_fmt_name(cgotype) + + field_name =3D xenlight_golang_fmt_name('{}_union'.format(keyname)) + s +=3D 'tmp, ok :=3D x.{}.({})\n'.format(field_name,gotype) + s +=3D 'if !ok {\n' + s +=3D 'return errors.New("wrong type for union key {}")\n'.format= (keyname) + s +=3D '}\n' + + s +=3D 'var {} C.{}\n'.format(f.name,cgotype) + for uf in f.type.fields: + s +=3D xenlight_golang_convert_to_C(uf,cvarname=3Df.name, + govarname=3D'tmp') + + # The union is still represented as Go []byte. + s +=3D '{}Bytes :=3D C.GoBytes(unsafe.Pointer(&{}),C.sizeof_{})\n'= .format(f.name, + = f.name, + = cgotype) + s +=3D 'copy(xc.{}[:],{}Bytes)\n'.format(union_name,f.name) + + # End switch statement + s +=3D 'default:\n' + err_string =3D '"invalid union key \'%v\'", x.{}'.format(gokeyname) + s +=3D 'return fmt.Errorf({})'.format(err_string) + s +=3D '}\n' =20 return s =20 diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/h= elpers.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) (er= r error) { xc.state =3D C.int(x.State) xc.evtch =3D C.int(x.Evtch) xc.rref =3D C.int(x.Rref) + xc.connection =3D C.libxl_channel_connection(x.Connection) + switch x.Connection { + case ChannelConnectionPty: + tmp, ok :=3D 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 !=3D "" { + pty.path =3D C.CString(tmp.Path) + } + ptyBytes :=3D 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) + } =20 return nil } @@ -1124,6 +1140,189 @@ func (x *DomainBuildInfo) toC(xc *C.libxl_domain_bu= ild_info) (err error) { return err } xc.tee =3D C.libxl_tee_type(x.Tee) + xc._type =3D C.libxl_domain_type(x.Type) + switch x.Type { + case DomainTypeHvm: + tmp, ok :=3D 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 !=3D "" { + hvm.firmware =3D C.CString(tmp.Firmware) + } + hvm.bios =3D C.libxl_bios_type(tmp.Bios) + if err :=3D tmp.Pae.toC(&hvm.pae); err !=3D nil { + return err + } + if err :=3D tmp.Apic.toC(&hvm.apic); err !=3D nil { + return err + } + if err :=3D tmp.Acpi.toC(&hvm.acpi); err !=3D nil { + return err + } + if err :=3D tmp.AcpiS3.toC(&hvm.acpi_s3); err !=3D nil { + return err + } + if err :=3D tmp.AcpiS4.toC(&hvm.acpi_s4); err !=3D nil { + return err + } + if err :=3D tmp.AcpiLaptopSlate.toC(&hvm.acpi_laptop_slate); err !=3D ni= l { + return err + } + if err :=3D tmp.Nx.toC(&hvm.nx); err !=3D nil { + return err + } + if err :=3D tmp.Viridian.toC(&hvm.viridian); err !=3D nil { + return err + } + if err :=3D tmp.ViridianEnable.toC(&hvm.viridian_enable); err !=3D nil { + return err + } + if err :=3D tmp.ViridianDisable.toC(&hvm.viridian_disable); err !=3D nil= { + return err + } + if tmp.Timeoffset !=3D "" { + hvm.timeoffset =3D C.CString(tmp.Timeoffset) + } + if err :=3D tmp.Hpet.toC(&hvm.hpet); err !=3D nil { + return err + } + if err :=3D tmp.VptAlign.toC(&hvm.vpt_align); err !=3D nil { + return err + } + hvm.mmio_hole_memkb =3D C.uint64_t(tmp.MmioHoleMemkb) + hvm.timer_mode =3D C.libxl_timer_mode(tmp.TimerMode) + if err :=3D tmp.NestedHvm.toC(&hvm.nested_hvm); err !=3D nil { + return err + } + if err :=3D tmp.Altp2M.toC(&hvm.altp2m); err !=3D nil { + return err + } + if tmp.SystemFirmware !=3D "" { + hvm.system_firmware =3D C.CString(tmp.SystemFirmware) + } + if tmp.SmbiosFirmware !=3D "" { + hvm.smbios_firmware =3D C.CString(tmp.SmbiosFirmware) + } + if tmp.AcpiFirmware !=3D "" { + hvm.acpi_firmware =3D C.CString(tmp.AcpiFirmware) + } + hvm.hdtype =3D C.libxl_hdtype(tmp.Hdtype) + if err :=3D tmp.Nographic.toC(&hvm.nographic); err !=3D nil { + return err + } + if err :=3D tmp.Vga.toC(&hvm.vga); err !=3D nil { + return err + } + if err :=3D tmp.Vnc.toC(&hvm.vnc); err !=3D nil { + return err + } + if tmp.Keymap !=3D "" { + hvm.keymap =3D C.CString(tmp.Keymap) + } + if err :=3D tmp.Sdl.toC(&hvm.sdl); err !=3D nil { + return err + } + if err :=3D tmp.Spice.toC(&hvm.spice); err !=3D nil { + return err + } + if err :=3D tmp.GfxPassthru.toC(&hvm.gfx_passthru); err !=3D nil { + return err + } + hvm.gfx_passthru_kind =3D C.libxl_gfx_passthru_kind(tmp.GfxPassthruKind) + if tmp.Serial !=3D "" { + hvm.serial =3D C.CString(tmp.Serial) + } + if tmp.Boot !=3D "" { + hvm.boot =3D C.CString(tmp.Boot) + } + if err :=3D tmp.Usb.toC(&hvm.usb); err !=3D nil { + return err + } + hvm.usbversion =3D C.int(tmp.Usbversion) + if tmp.Usbdevice !=3D "" { + hvm.usbdevice =3D C.CString(tmp.Usbdevice) + } + if err :=3D tmp.VkbDevice.toC(&hvm.vkb_device); err !=3D nil { + return err + } + if tmp.Soundhw !=3D "" { + hvm.soundhw =3D C.CString(tmp.Soundhw) + } + if err :=3D tmp.XenPlatformPci.toC(&hvm.xen_platform_pci); err !=3D nil { + return err + } + if err :=3D tmp.UsbdeviceList.toC(&hvm.usbdevice_list); err !=3D nil { + return err + } + hvm.vendor_device =3D C.libxl_vendor_device(tmp.VendorDevice) + if err :=3D tmp.MsVmGenid.toC(&hvm.ms_vm_genid); err !=3D nil { + return err + } + if err :=3D tmp.SerialList.toC(&hvm.serial_list); err !=3D nil { + return err + } + if err :=3D tmp.Rdm.toC(&hvm.rdm); err !=3D nil { + return err + } + hvm.rdm_mem_boundary_memkb =3D C.uint64_t(tmp.RdmMemBoundaryMemkb) + hvm.mca_caps =3D C.uint64_t(tmp.McaCaps) + hvmBytes :=3D C.GoBytes(unsafe.Pointer(&hvm), C.sizeof_libxl_domain_buil= d_info_type_union_hvm) + copy(xc.u[:], hvmBytes) + case DomainTypePv: + tmp, ok :=3D 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 !=3D "" { + pv.kernel =3D C.CString(tmp.Kernel) + } + pv.slack_memkb =3D C.uint64_t(tmp.SlackMemkb) + if tmp.Bootloader !=3D "" { + pv.bootloader =3D C.CString(tmp.Bootloader) + } + if err :=3D tmp.BootloaderArgs.toC(&pv.bootloader_args); err !=3D nil { + return err + } + if tmp.Cmdline !=3D "" { + pv.cmdline =3D C.CString(tmp.Cmdline) + } + if tmp.Ramdisk !=3D "" { + pv.ramdisk =3D C.CString(tmp.Ramdisk) + } + if tmp.Features !=3D "" { + pv.features =3D C.CString(tmp.Features) + } + if err :=3D tmp.E820Host.toC(&pv.e820_host); err !=3D nil { + return err + } + pvBytes :=3D C.GoBytes(unsafe.Pointer(&pv), C.sizeof_libxl_domain_build_= info_type_union_pv) + copy(xc.u[:], pvBytes) + case DomainTypePvh: + tmp, ok :=3D 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 :=3D tmp.Pvshim.toC(&pvh.pvshim); err !=3D nil { + return err + } + if tmp.PvshimPath !=3D "" { + pvh.pvshim_path =3D C.CString(tmp.PvshimPath) + } + if tmp.PvshimCmdline !=3D "" { + pvh.pvshim_cmdline =3D C.CString(tmp.PvshimCmdline) + } + if tmp.PvshimExtra !=3D "" { + pvh.pvshim_extra =3D C.CString(tmp.PvshimExtra) + } + pvhBytes :=3D C.GoBytes(unsafe.Pointer(&pvh), C.sizeof_libxl_domain_buil= d_info_type_union_pvh) + copy(xc.u[:], pvhBytes) + default: + return fmt.Errorf("invalid union key '%v'", x.Type) + } xc.arch_arm.gic_version =3D C.libxl_gic_version(x.ArchArm.GicVersion) xc.arch_arm.vuart =3D C.libxl_vuart_type(x.ArchArm.Vuart) xc.altp2m =3D C.libxl_altp2m_mode(x.Altp2M) @@ -1689,6 +1888,21 @@ func (x *DeviceUsbdev) toC(xc *C.libxl_device_usbdev= ) (err error) { =20 xc.ctrl =3D C.libxl_devid(x.Ctrl) xc.port =3D C.int(x.Port) + xc._type =3D C.libxl_usbdev_type(x.Type) + switch x.Type { + case UsbdevTypeHostdev: + tmp, ok :=3D 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 =3D C.uint8_t(tmp.Hostbus) + hostdev.hostaddr =3D C.uint8_t(tmp.Hostaddr) + hostdevBytes :=3D C.GoBytes(unsafe.Pointer(&hostdev), C.sizeof_libxl_dev= ice_usbdev_type_union_hostdev) + copy(xc.u[:], hostdevBytes) + default: + return fmt.Errorf("invalid union key '%v'", x.Type) + } =20 return nil } @@ -1848,6 +2062,22 @@ func (x *DeviceChannel) toC(xc *C.libxl_device_chann= el) (err error) { if x.Name !=3D "" { xc.name =3D C.CString(x.Name) } + xc.connection =3D C.libxl_channel_connection(x.Connection) + switch x.Connection { + case ChannelConnectionSocket: + tmp, ok :=3D 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 !=3D "" { + socket.path =3D C.CString(tmp.Path) + } + socketBytes :=3D C.GoBytes(unsafe.Pointer(&socket), C.sizeof_libxl_devic= e_channel_connection_union_socket) + copy(xc.u[:], socketBytes) + default: + return fmt.Errorf("invalid union key '%v'", x.Connection) + } =20 return nil } @@ -2911,6 +3141,43 @@ func (x *Event) toC(xc *C.libxl_event) (err error) { return err } xc.for_user =3D C.uint64_t(x.ForUser) + xc._type =3D C.libxl_event_type(x.Type) + switch x.Type { + case EventTypeDomainShutdown: + tmp, ok :=3D 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 =3D C.uint8_t(tmp.ShutdownReason) + domain_shutdownBytes :=3D C.GoBytes(unsafe.Pointer(&domain_shutdown), C.= sizeof_libxl_event_type_union_domain_shutdown) + copy(xc.u[:], domain_shutdownBytes) + case EventTypeDiskEject: + tmp, ok :=3D 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 !=3D "" { + disk_eject.vdev =3D C.CString(tmp.Vdev) + } + if err :=3D tmp.Disk.toC(&disk_eject.disk); err !=3D nil { + return err + } + disk_ejectBytes :=3D C.GoBytes(unsafe.Pointer(&disk_eject), C.sizeof_lib= xl_event_type_union_disk_eject) + copy(xc.u[:], disk_ejectBytes) + case EventTypeOperationComplete: + tmp, ok :=3D 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 =3D C.int(tmp.Rc) + operation_completeBytes :=3D C.GoBytes(unsafe.Pointer(&operation_complet= e), C.sizeof_libxl_event_type_union_operation_complete) + copy(xc.u[:], operation_completeBytes) + default: + return fmt.Errorf("invalid union key '%v'", x.Type) + } =20 return nil } @@ -2994,6 +3261,33 @@ func (x *PsrHwInfo) toC(xc *C.libxl_psr_hw_info) (er= r error) { }() =20 xc.id =3D C.uint32_t(x.Id) + xc._type =3D C.libxl_psr_feat_type(x.Type) + switch x.Type { + case PsrFeatTypeCat: + tmp, ok :=3D 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 =3D C.uint32_t(tmp.CosMax) + cat.cbm_len =3D C.uint32_t(tmp.CbmLen) + cat.cdp_enabled =3D C.bool(tmp.CdpEnabled) + catBytes :=3D C.GoBytes(unsafe.Pointer(&cat), C.sizeof_libxl_psr_hw_info= _type_union_cat) + copy(xc.u[:], catBytes) + case PsrFeatTypeMba: + tmp, ok :=3D 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 =3D C.uint32_t(tmp.CosMax) + mba.thrtl_max =3D C.uint32_t(tmp.ThrtlMax) + mba.linear =3D C.bool(tmp.Linear) + mbaBytes :=3D 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) + } =20 return nil } --=20 2.17.1 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel From nobody Mon May 6 11:55:13 2024 Delivered-To: importer@patchew.org Received-SPF: none (zohomail.com: 192.237.175.120 is neither permitted nor denied by domain of lists.xenproject.org) client-ip=192.237.175.120; envelope-from=xen-devel-bounces@lists.xenproject.org; helo=lists.xenproject.org; Authentication-Results: mx.zohomail.com; dkim=fail; spf=none (zohomail.com: 192.237.175.120 is neither permitted nor denied by domain of lists.xenproject.org) smtp.mailfrom=xen-devel-bounces@lists.xenproject.org; dmarc=fail(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1578171744; cv=none; d=zohomail.com; s=zohoarc; b=OJQIHGhjFR/W7wXrmRdBV6TTAv48tumZtmhReOWYijk1yZqrK2ZDwJzcYeAwVn2xbpBByBr/4QeirZiWvjHFcA0rLpkDHSEw1kdtrV5H6BX/6Wjg7LpnGWN+e5lD32Sp6e+K/2rvGJVoTF9pb/xpFlk06WPUtIjDm5CcRAuVeRg= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1578171744; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=hCX48h1xmzEVs9/qaCZKzFvHuBJADlgnxoXSQWVho4A=; b=lLJ4g6VLAVcPTi6xtTKgFvBJZMADdR5FbfJjT4xbSIrSg3h5RlIOx6wDA77+QMBzia65Lhm9XTdyqAe3E1VuraCE5aZZAfIKX9S2mn1kCPVvyPPVNzzTrlSadwo9pgUP5gilqPQqUmIUVmiy6v2c72BzdOA4UnBkkbdXeYmbjw0= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; spf=none (zohomail.com: 192.237.175.120 is neither permitted nor denied by domain of lists.xenproject.org) smtp.mailfrom=xen-devel-bounces@lists.xenproject.org; dmarc=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) by mx.zohomail.com with SMTPS id 15781717444811008.7898793218582; Sat, 4 Jan 2020 13:02:24 -0800 (PST) Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1inqYB-0003I2-6Q; Sat, 04 Jan 2020 21:01:35 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1inqY9-0003HX-FA for xen-devel@lists.xenproject.org; Sat, 04 Jan 2020 21:01:33 +0000 Received: from mail-yw1-xc42.google.com (unknown [2607:f8b0:4864:20::c42]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 5cbfff66-2f35-11ea-88e7-bc764e2007e4; Sat, 04 Jan 2020 21:01:22 +0000 (UTC) Received: by mail-yw1-xc42.google.com with SMTP id i190so20186903ywc.2 for ; Sat, 04 Jan 2020 13:01:22 -0800 (PST) Received: from four.lan (cpe-67-241-56-252.twcny.res.rr.com. [67.241.56.252]) by smtp.gmail.com with ESMTPSA id r10sm26366714ywr.97.2020.01.04.13.01.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 04 Jan 2020 13:01:20 -0800 (PST) X-Inumbo-ID: 5cbfff66-2f35-11ea-88e7-bc764e2007e4 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 :in-reply-to:references; bh=8uEa99M9x2wXbhHwsjyTaxsFQhy/l7dJJ1L/b7JvTTQ=; b=pIqVdiPOtq69gMSnewi5m7PtVmTPuREHyfNFAiMI5GRAhc5N+7K+osHPpIp0eV6WDY dVuzL9KQ+qE8qScQkxTJeiYQUEP8pel0dFj6aAEX10/iQ5phqoocj3vEGK5o9YAThQAn 8wwrRldLX4/OORkZLYJ+KlCNvnzZFJctJ7yi8EDJog3P7ndQA+IAMGJUoLsRSu09p1oo h46Mnc+OTt5RHAXuu2CElu3IJQrBHgnm8rnHsCRcSBldBCEYioOAClnxj1RdSXhGVubZ Q4TOTNugPq75M8ahdaLtk9eIJIDIyH4X9wRouwkwTCjXMGIZLO8+L5c4HxOsQHrtPQ+J Gbqg== 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:in-reply-to:references; bh=8uEa99M9x2wXbhHwsjyTaxsFQhy/l7dJJ1L/b7JvTTQ=; b=XeCUO8rbUgpme9dgwhTnHSP7vrwCECWHWBEb3rpbya4S7yZdX1lv4fPJQNx0db5DJH W+PUUIkftwfed6eyFRSBaKBzG3yF/oXtXyNUf58I99jSrGwDszaDiICNDGbqgEhLf0Gg Ag1cPGRn98wDdTwBSuMGGJLgi9X/Eg6poc3tCj34Pzj8LvW9FPXuWg84IWHUG3Y6tY7P IVwzBxbIBWfeWtrdvbdCBQ9eGUyUmY9KJMpkxMrsOuCdZdp9gDrGBAro9w7Zvr6K8jTj bMWyYpKguZevVEwOmO7AnbEfjBvnQvsLRmItjNPb0DnpVO69K/pVZ8+SHVyOYhVaf67w 0TPw== X-Gm-Message-State: APjAAAUo4kImaVnbTEruWx0DBPMInBd3qiGPIOhN7TF9HzCqzAUgXKs3 BXzebTcEqtQAng8LTfXwQU5wZ3es X-Google-Smtp-Source: APXvYqxqi1DuhR4qat4wegzsreBqDvyClcMp6nbzpvbYHia0Ee5tao75rkuq0eaoE0j23q0UuXxhrw== X-Received: by 2002:a81:6d91:: with SMTP id i139mr74255773ywc.401.1578171681459; Sat, 04 Jan 2020 13:01:21 -0800 (PST) From: Nick Rosbrook X-Google-Original-From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Sat, 4 Jan 2020 16:00:53 -0500 Message-Id: <5bf5727f88e00adb9c973e2b884292d369d1b3e9.1578170151.git.rosbrookn@ainfosec.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Subject: [Xen-devel] [PATCH v5 3/3] golang/xenlight: implement array Go to C 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 , George Dunlap , Wei Liu MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Signed-off-by: Nick Rosbrook Reviewed-by: George Dunlap --- 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/ge= ngotypes.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 =3D None, typename = =3D None, nested =3D False): for f in ty.fields: if f.type.typename is not None: if isinstance(f.type, idl.Array): - # TODO + body +=3D xenlight_golang_array_to_C(f) continue =20 body +=3D xenlight_golang_convert_to_C(f) @@ -580,6 +580,45 @@ def xenlight_golang_union_to_C(ty =3D None, union_name= =3D '', =20 return s =20 +def xenlight_golang_array_to_C(ty =3D None): + s =3D '' + + gotypename =3D xenlight_golang_fmt_name(ty.type.elem_type.typename) + goname =3D xenlight_golang_fmt_name(ty.name) + ctypename =3D ty.type.elem_type.typename + cname =3D ty.name + clenvar =3D ty.type.lenvar.name + golenvar =3D xenlight_golang_fmt_name(clenvar,exported=3DFalse) + + is_enum =3D isinstance(ty.type.elem_type,idl.Enumeration) + if gotypename in go_builtin_types or is_enum: + s +=3D 'if {} :=3D len(x.{}); {} > 0 {{\n'.format(golenvar,goname,= golenvar) + s +=3D 'xc.{} =3D (*C.{})(C.malloc(C.size_t({}*{})))\n'.format(cna= me,ctypename, + golenva= r,golenvar) + s +=3D 'xc.{} =3D C.int({})\n'.format(clenvar,golenvar) + s +=3D 'c{} :=3D (*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.= format(goname, + ctyp= ename,cname, + gole= nvar,golenvar) + s +=3D 'for i,v :=3D range x.{} {{\n'.format(goname) + s +=3D 'c{}[i] =3D C.{}(v)\n'.format(goname,ctypename) + s +=3D '}\n}\n' + + return s + + s +=3D 'if {} :=3D len(x.{}); {} > 0 {{\n'.format(golenvar,goname,gole= nvar) + s +=3D 'xc.{} =3D (*C.{})(C.malloc(C.ulong({})*C.sizeof_{}))\n'.format= (cname,ctypename, + golenva= r,ctypename) + s +=3D 'xc.{} =3D C.int({})\n'.format(clenvar,golenvar) + s +=3D 'c{} :=3D (*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.form= at(goname, + c= typename,cname, + g= olenvar,golenvar) + s +=3D 'for i,v :=3D range x.{} {{\n'.format(goname) + s +=3D 'if err :=3D v.toC(&c{}[i]); err !=3D nil {{\n'.format(goname) + s +=3D 'return err\n' + s +=3D '}\n}\n}\n' + + return s + def xenlight_golang_fmt_name(name, exported =3D True): """ Take a given type name and return an diff --git a/tools/golang/xenlight/helpers.gen.go b/tools/golang/xenlight/h= elpers.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_p= arams) (err error) { }() =20 xc.sched =3D C.libxl_scheduler(x.Sched) + if numVcpus :=3D len(x.Vcpus); numVcpus > 0 { + xc.vcpus =3D (*C.libxl_sched_params)(C.malloc(C.ulong(numVcpus) * C.size= of_libxl_sched_params)) + xc.num_vcpus =3D C.int(numVcpus) + cVcpus :=3D (*[1 << 28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:= numVcpus:numVcpus] + for i, v :=3D range x.Vcpus { + if err :=3D v.toC(&cVcpus[i]); err !=3D nil { + return err + } + } + } =20 return nil } @@ -703,6 +713,14 @@ func (x *VnodeInfo) toC(xc *C.libxl_vnode_info) (err e= rror) { }() =20 xc.memkb =3D C.uint64_t(x.Memkb) + if numDistances :=3D len(x.Distances); numDistances > 0 { + xc.distances =3D (*C.uint32_t)(C.malloc(C.size_t(numDistances * numDista= nces))) + xc.num_distances =3D C.int(numDistances) + cDistances :=3D (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.distances))[:nu= mDistances:numDistances] + for i, v :=3D range x.Distances { + cDistances[i] =3D C.uint32_t(v) + } + } xc.pnode =3D C.uint32_t(x.Pnode) if err :=3D x.Vcpus.toC(&xc.vcpus); err !=3D nil { return err @@ -1050,6 +1068,26 @@ func (x *DomainBuildInfo) toC(xc *C.libxl_domain_bui= ld_info) (err error) { if err :=3D x.Nodemap.toC(&xc.nodemap); err !=3D nil { return err } + if numVcpuHardAffinity :=3D len(x.VcpuHardAffinity); numVcpuHardAffinity = > 0 { + xc.vcpu_hard_affinity =3D (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuHard= Affinity) * C.sizeof_libxl_bitmap)) + xc.num_vcpu_hard_affinity =3D C.int(numVcpuHardAffinity) + cVcpuHardAffinity :=3D (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu= _hard_affinity))[:numVcpuHardAffinity:numVcpuHardAffinity] + for i, v :=3D range x.VcpuHardAffinity { + if err :=3D v.toC(&cVcpuHardAffinity[i]); err !=3D nil { + return err + } + } + } + if numVcpuSoftAffinity :=3D len(x.VcpuSoftAffinity); numVcpuSoftAffinity = > 0 { + xc.vcpu_soft_affinity =3D (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuSoft= Affinity) * C.sizeof_libxl_bitmap)) + xc.num_vcpu_soft_affinity =3D C.int(numVcpuSoftAffinity) + cVcpuSoftAffinity :=3D (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu= _soft_affinity))[:numVcpuSoftAffinity:numVcpuSoftAffinity] + for i, v :=3D range x.VcpuSoftAffinity { + if err :=3D v.toC(&cVcpuSoftAffinity[i]); err !=3D nil { + return err + } + } + } if err :=3D x.NumaPlacement.toC(&xc.numa_placement); err !=3D nil { return err } @@ -1076,6 +1114,16 @@ func (x *DomainBuildInfo) toC(xc *C.libxl_domain_bui= ld_info) (err error) { if x.BlkdevStart !=3D "" { xc.blkdev_start =3D C.CString(x.BlkdevStart) } + if numVnumaNodes :=3D len(x.VnumaNodes); numVnumaNodes > 0 { + xc.vnuma_nodes =3D (*C.libxl_vnode_info)(C.malloc(C.ulong(numVnumaNodes)= * C.sizeof_libxl_vnode_info)) + xc.num_vnuma_nodes =3D C.int(numVnumaNodes) + cVnumaNodes :=3D (*[1 << 28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_= nodes))[:numVnumaNodes:numVnumaNodes] + for i, v :=3D range x.VnumaNodes { + if err :=3D v.toC(&cVnumaNodes[i]); err !=3D nil { + return err + } + } + } xc.max_grant_frames =3D C.uint32_t(x.MaxGrantFrames) xc.max_maptrack_frames =3D C.uint32_t(x.MaxMaptrackFrames) xc.device_model_version =3D C.libxl_device_model_version(x.DeviceModelVer= sion) @@ -1104,6 +1152,34 @@ func (x *DomainBuildInfo) toC(xc *C.libxl_domain_bui= ld_info) (err error) { if err :=3D x.SchedParams.toC(&xc.sched_params); err !=3D nil { return err } + if numIoports :=3D len(x.Ioports); numIoports > 0 { + xc.ioports =3D (*C.libxl_ioport_range)(C.malloc(C.ulong(numIoports) * C.= sizeof_libxl_ioport_range)) + xc.num_ioports =3D C.int(numIoports) + cIoports :=3D (*[1 << 28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports= ))[:numIoports:numIoports] + for i, v :=3D range x.Ioports { + if err :=3D v.toC(&cIoports[i]); err !=3D nil { + return err + } + } + } + if numIrqs :=3D len(x.Irqs); numIrqs > 0 { + xc.irqs =3D (*C.uint32_t)(C.malloc(C.size_t(numIrqs * numIrqs))) + xc.num_irqs =3D C.int(numIrqs) + cIrqs :=3D (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:numIrqs:numI= rqs] + for i, v :=3D range x.Irqs { + cIrqs[i] =3D C.uint32_t(v) + } + } + if numIomem :=3D len(x.Iomem); numIomem > 0 { + xc.iomem =3D (*C.libxl_iomem_range)(C.malloc(C.ulong(numIomem) * C.sizeo= f_libxl_iomem_range)) + xc.num_iomem =3D C.int(numIomem) + cIomem :=3D (*[1 << 28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:n= umIomem:numIomem] + for i, v :=3D range x.Iomem { + if err :=3D v.toC(&cIomem[i]); err !=3D nil { + return err + } + } + } if err :=3D x.ClaimMode.toC(&xc.claim_mode); err !=3D nil { return err } @@ -2136,6 +2212,16 @@ func (x *DeviceVdispl) toC(xc *C.libxl_device_vdispl= ) (err error) { } xc.devid =3D C.libxl_devid(x.Devid) xc.be_alloc =3D C.bool(x.BeAlloc) + if numConnectors :=3D len(x.Connectors); numConnectors > 0 { + xc.connectors =3D (*C.libxl_connector_param)(C.malloc(C.ulong(numConnect= ors) * C.sizeof_libxl_connector_param)) + xc.num_connectors =3D C.int(numConnectors) + cConnectors :=3D (*[1 << 28]C.libxl_connector_param)(unsafe.Pointer(xc.c= onnectors))[:numConnectors:numConnectors] + for i, v :=3D range x.Connectors { + if err :=3D v.toC(&cConnectors[i]); err !=3D nil { + return err + } + } + } =20 return nil } @@ -2167,6 +2253,22 @@ func (x *VsndParams) toC(xc *C.libxl_vsnd_params) (e= rr error) { } }() =20 + if numSampleRates :=3D len(x.SampleRates); numSampleRates > 0 { + xc.sample_rates =3D (*C.uint32_t)(C.malloc(C.size_t(numSampleRates * num= SampleRates))) + xc.num_sample_rates =3D C.int(numSampleRates) + cSampleRates :=3D (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.sample_rates)= )[:numSampleRates:numSampleRates] + for i, v :=3D range x.SampleRates { + cSampleRates[i] =3D C.uint32_t(v) + } + } + if numSampleFormats :=3D len(x.SampleFormats); numSampleFormats > 0 { + xc.sample_formats =3D (*C.libxl_vsnd_pcm_format)(C.malloc(C.size_t(numSa= mpleFormats * numSampleFormats))) + xc.num_sample_formats =3D C.int(numSampleFormats) + cSampleFormats :=3D (*[1 << 28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(x= c.sample_formats))[:numSampleFormats:numSampleFormats] + for i, v :=3D range x.SampleFormats { + cSampleFormats[i] =3D C.libxl_vsnd_pcm_format(v) + } + } xc.channels_min =3D C.uint32_t(x.ChannelsMin) xc.channels_max =3D C.uint32_t(x.ChannelsMax) xc.buffer_size =3D C.uint32_t(x.BufferSize) @@ -2232,6 +2334,16 @@ func (x *VsndPcm) toC(xc *C.libxl_vsnd_pcm) (err err= or) { if err :=3D x.Params.toC(&xc.params); err !=3D nil { return err } + if numVsndStreams :=3D len(x.Streams); numVsndStreams > 0 { + xc.streams =3D (*C.libxl_vsnd_stream)(C.malloc(C.ulong(numVsndStreams) *= C.sizeof_libxl_vsnd_stream)) + xc.num_vsnd_streams =3D C.int(numVsndStreams) + cStreams :=3D (*[1 << 28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams)= )[:numVsndStreams:numVsndStreams] + for i, v :=3D range x.Streams { + if err :=3D v.toC(&cStreams[i]); err !=3D nil { + return err + } + } + } =20 return nil } @@ -2278,6 +2390,16 @@ func (x *DeviceVsnd) toC(xc *C.libxl_device_vsnd) (e= rr error) { if err :=3D x.Params.toC(&xc.params); err !=3D nil { return err } + if numVsndPcms :=3D len(x.Pcms); numVsndPcms > 0 { + xc.pcms =3D (*C.libxl_vsnd_pcm)(C.malloc(C.ulong(numVsndPcms) * C.sizeof= _libxl_vsnd_pcm)) + xc.num_vsnd_pcms =3D C.int(numVsndPcms) + cPcms :=3D (*[1 << 28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:numVsn= dPcms:numVsndPcms] + for i, v :=3D range x.Pcms { + if err :=3D v.toC(&cPcms[i]); err !=3D nil { + return err + } + } + } =20 return nil } @@ -2431,6 +2553,156 @@ func (x *DomainConfig) toC(xc *C.libxl_domain_confi= g) (err error) { if err :=3D x.BInfo.toC(&xc.b_info); err !=3D nil { return err } + if numDisks :=3D len(x.Disks); numDisks > 0 { + xc.disks =3D (*C.libxl_device_disk)(C.malloc(C.ulong(numDisks) * C.sizeo= f_libxl_device_disk)) + xc.num_disks =3D C.int(numDisks) + cDisks :=3D (*[1 << 28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:n= umDisks:numDisks] + for i, v :=3D range x.Disks { + if err :=3D v.toC(&cDisks[i]); err !=3D nil { + return err + } + } + } + if numNics :=3D len(x.Nics); numNics > 0 { + xc.nics =3D (*C.libxl_device_nic)(C.malloc(C.ulong(numNics) * C.sizeof_l= ibxl_device_nic)) + xc.num_nics =3D C.int(numNics) + cNics :=3D (*[1 << 28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:numN= ics:numNics] + for i, v :=3D range x.Nics { + if err :=3D v.toC(&cNics[i]); err !=3D nil { + return err + } + } + } + if numPcidevs :=3D len(x.Pcidevs); numPcidevs > 0 { + xc.pcidevs =3D (*C.libxl_device_pci)(C.malloc(C.ulong(numPcidevs) * C.si= zeof_libxl_device_pci)) + xc.num_pcidevs =3D C.int(numPcidevs) + cPcidevs :=3D (*[1 << 28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))= [:numPcidevs:numPcidevs] + for i, v :=3D range x.Pcidevs { + if err :=3D v.toC(&cPcidevs[i]); err !=3D nil { + return err + } + } + } + if numRdms :=3D len(x.Rdms); numRdms > 0 { + xc.rdms =3D (*C.libxl_device_rdm)(C.malloc(C.ulong(numRdms) * C.sizeof_l= ibxl_device_rdm)) + xc.num_rdms =3D C.int(numRdms) + cRdms :=3D (*[1 << 28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:numR= dms:numRdms] + for i, v :=3D range x.Rdms { + if err :=3D v.toC(&cRdms[i]); err !=3D nil { + return err + } + } + } + if numDtdevs :=3D len(x.Dtdevs); numDtdevs > 0 { + xc.dtdevs =3D (*C.libxl_device_dtdev)(C.malloc(C.ulong(numDtdevs) * C.si= zeof_libxl_device_dtdev)) + xc.num_dtdevs =3D C.int(numDtdevs) + cDtdevs :=3D (*[1 << 28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))= [:numDtdevs:numDtdevs] + for i, v :=3D range x.Dtdevs { + if err :=3D v.toC(&cDtdevs[i]); err !=3D nil { + return err + } + } + } + if numVfbs :=3D len(x.Vfbs); numVfbs > 0 { + xc.vfbs =3D (*C.libxl_device_vfb)(C.malloc(C.ulong(numVfbs) * C.sizeof_l= ibxl_device_vfb)) + xc.num_vfbs =3D C.int(numVfbs) + cVfbs :=3D (*[1 << 28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:numV= fbs:numVfbs] + for i, v :=3D range x.Vfbs { + if err :=3D v.toC(&cVfbs[i]); err !=3D nil { + return err + } + } + } + if numVkbs :=3D len(x.Vkbs); numVkbs > 0 { + xc.vkbs =3D (*C.libxl_device_vkb)(C.malloc(C.ulong(numVkbs) * C.sizeof_l= ibxl_device_vkb)) + xc.num_vkbs =3D C.int(numVkbs) + cVkbs :=3D (*[1 << 28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:numV= kbs:numVkbs] + for i, v :=3D range x.Vkbs { + if err :=3D v.toC(&cVkbs[i]); err !=3D nil { + return err + } + } + } + if numVtpms :=3D len(x.Vtpms); numVtpms > 0 { + xc.vtpms =3D (*C.libxl_device_vtpm)(C.malloc(C.ulong(numVtpms) * C.sizeo= f_libxl_device_vtpm)) + xc.num_vtpms =3D C.int(numVtpms) + cVtpms :=3D (*[1 << 28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:n= umVtpms:numVtpms] + for i, v :=3D range x.Vtpms { + if err :=3D v.toC(&cVtpms[i]); err !=3D nil { + return err + } + } + } + if numP9S :=3D len(x.P9S); numP9S > 0 { + xc.p9s =3D (*C.libxl_device_p9)(C.malloc(C.ulong(numP9S) * C.sizeof_libx= l_device_p9)) + xc.num_p9s =3D C.int(numP9S) + cP9S :=3D (*[1 << 28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:numP9S:= numP9S] + for i, v :=3D range x.P9S { + if err :=3D v.toC(&cP9S[i]); err !=3D nil { + return err + } + } + } + if numPvcallsifs :=3D len(x.Pvcallsifs); numPvcallsifs > 0 { + xc.pvcallsifs =3D (*C.libxl_device_pvcallsif)(C.malloc(C.ulong(numPvcall= sifs) * C.sizeof_libxl_device_pvcallsif)) + xc.num_pvcallsifs =3D C.int(numPvcallsifs) + cPvcallsifs :=3D (*[1 << 28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.= pvcallsifs))[:numPvcallsifs:numPvcallsifs] + for i, v :=3D range x.Pvcallsifs { + if err :=3D v.toC(&cPvcallsifs[i]); err !=3D nil { + return err + } + } + } + if numVdispls :=3D len(x.Vdispls); numVdispls > 0 { + xc.vdispls =3D (*C.libxl_device_vdispl)(C.malloc(C.ulong(numVdispls) * C= .sizeof_libxl_device_vdispl)) + xc.num_vdispls =3D C.int(numVdispls) + cVdispls :=3D (*[1 << 28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispl= s))[:numVdispls:numVdispls] + for i, v :=3D range x.Vdispls { + if err :=3D v.toC(&cVdispls[i]); err !=3D nil { + return err + } + } + } + if numVsnds :=3D len(x.Vsnds); numVsnds > 0 { + xc.vsnds =3D (*C.libxl_device_vsnd)(C.malloc(C.ulong(numVsnds) * C.sizeo= f_libxl_device_vsnd)) + xc.num_vsnds =3D C.int(numVsnds) + cVsnds :=3D (*[1 << 28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:n= umVsnds:numVsnds] + for i, v :=3D range x.Vsnds { + if err :=3D v.toC(&cVsnds[i]); err !=3D nil { + return err + } + } + } + if numChannels :=3D len(x.Channels); numChannels > 0 { + xc.channels =3D (*C.libxl_device_channel)(C.malloc(C.ulong(numChannels) = * C.sizeof_libxl_device_channel)) + xc.num_channels =3D C.int(numChannels) + cChannels :=3D (*[1 << 28]C.libxl_device_channel)(unsafe.Pointer(xc.chan= nels))[:numChannels:numChannels] + for i, v :=3D range x.Channels { + if err :=3D v.toC(&cChannels[i]); err !=3D nil { + return err + } + } + } + if numUsbctrls :=3D len(x.Usbctrls); numUsbctrls > 0 { + xc.usbctrls =3D (*C.libxl_device_usbctrl)(C.malloc(C.ulong(numUsbctrls) = * C.sizeof_libxl_device_usbctrl)) + xc.num_usbctrls =3D C.int(numUsbctrls) + cUsbctrls :=3D (*[1 << 28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbc= trls))[:numUsbctrls:numUsbctrls] + for i, v :=3D range x.Usbctrls { + if err :=3D v.toC(&cUsbctrls[i]); err !=3D nil { + return err + } + } + } + if numUsbdevs :=3D len(x.Usbdevs); numUsbdevs > 0 { + xc.usbdevs =3D (*C.libxl_device_usbdev)(C.malloc(C.ulong(numUsbdevs) * C= .sizeof_libxl_device_usbdev)) + xc.num_usbdevs =3D C.int(numUsbdevs) + cUsbdevs :=3D (*[1 << 28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdev= s))[:numUsbdevs:numUsbdevs] + for i, v :=3D range x.Usbdevs { + if err :=3D v.toC(&cUsbdevs[i]); err !=3D nil { + return err + } + } + } xc.on_poweroff =3D C.libxl_action_on_shutdown(x.OnPoweroff) xc.on_reboot =3D C.libxl_action_on_shutdown(x.OnReboot) xc.on_watchdog =3D C.libxl_action_on_shutdown(x.OnWatchdog) @@ -2770,6 +3042,16 @@ func (x *Vdisplinfo) toC(xc *C.libxl_vdisplinfo) (er= r error) { xc.devid =3D C.libxl_devid(x.Devid) xc.state =3D C.int(x.State) xc.be_alloc =3D C.bool(x.BeAlloc) + if numConnectors :=3D len(x.Connectors); numConnectors > 0 { + xc.connectors =3D (*C.libxl_connectorinfo)(C.malloc(C.ulong(numConnector= s) * C.sizeof_libxl_connectorinfo)) + xc.num_connectors =3D C.int(numConnectors) + cConnectors :=3D (*[1 << 28]C.libxl_connectorinfo)(unsafe.Pointer(xc.con= nectors))[:numConnectors:numConnectors] + for i, v :=3D range x.Connectors { + if err :=3D v.toC(&cConnectors[i]); err !=3D nil { + return err + } + } + } =20 return nil } @@ -2814,6 +3096,17 @@ func (x *Pcminfo) toC(xc *C.libxl_pcminfo) (err erro= r) { } }() =20 + if numVsndStreams :=3D len(x.Streams); numVsndStreams > 0 { + xc.streams =3D (*C.libxl_streaminfo)(C.malloc(C.ulong(numVsndStreams) * = C.sizeof_libxl_streaminfo)) + xc.num_vsnd_streams =3D C.int(numVsndStreams) + cStreams :=3D (*[1 << 28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))= [:numVsndStreams:numVsndStreams] + for i, v :=3D range x.Streams { + if err :=3D v.toC(&cStreams[i]); err !=3D nil { + return err + } + } + } + return nil } =20 @@ -2853,6 +3146,16 @@ func (x *Vsndinfo) toC(xc *C.libxl_vsndinfo) (err er= ror) { xc.frontend_id =3D C.uint32_t(x.FrontendId) xc.devid =3D C.libxl_devid(x.Devid) xc.state =3D C.int(x.State) + if numVsndPcms :=3D len(x.Pcms); numVsndPcms > 0 { + xc.pcms =3D (*C.libxl_pcminfo)(C.malloc(C.ulong(numVsndPcms) * C.sizeof_= libxl_pcminfo)) + xc.num_vsnd_pcms =3D C.int(numVsndPcms) + cPcms :=3D (*[1 << 28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:numVsnd= Pcms:numVsndPcms] + for i, v :=3D range x.Pcms { + if err :=3D v.toC(&cPcms[i]); err !=3D nil { + return err + } + } + } =20 return nil } @@ -2915,6 +3218,14 @@ func (x *Numainfo) toC(xc *C.libxl_numainfo) (err er= ror) { =20 xc.size =3D C.uint64_t(x.Size) xc.free =3D C.uint64_t(x.Free) + if numDists :=3D len(x.Dists); numDists > 0 { + xc.dists =3D (*C.uint32_t)(C.malloc(C.size_t(numDists * numDists))) + xc.num_dists =3D C.int(numDists) + cDists :=3D (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.dists))[:numDists:n= umDists] + for i, v :=3D range x.Dists { + cDists[i] =3D C.uint32_t(v) + } + } =20 return nil } --=20 2.17.1 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel