From nobody Tue May 7 14:51:30 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=1577114338; cv=none; d=zohomail.com; s=zohoarc; b=Byikbd0lL9zDFqRVLiTk9Ox9kH+MQqSy+VsrGzp6zTFUIdacs5/h7IjfpMY/pqHtadtwwVFMnPtqZmLzJ2llUdkfv0CtrVjZWTKRusVUCcJ8lKIAZxayr9t7n+72wesB0icfUcO9y7rPnVEF6Xsd0AbcuiQ79LF8LOV2aFbb4u4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1577114338; 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=A5DXu8l5JcthtfbTV3XDdwgkmgXGrHlIneB1cH+/rBQ=; b=gMcQTF+kSfzojsYqO5eOoqok5lS7xOEycygFHBEqywWXqdUft/vhI9wuoh1eVAqxeDAw5JqD6kkNXN5aLRpCHUthNtVagI7bRZIIvUIMb9no7OP8hWKiG2gEBFD3p58eCwWBhoOg3dXJuaIevpanf1efYoiPeo4isMF7Mzje+l0= 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 1577114338802366.697519452729; Mon, 23 Dec 2019 07:18:58 -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 1ijPSy-0006Jx-WE; Mon, 23 Dec 2019 15:17:52 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1ijPSx-0006Jo-IP for xen-devel@lists.xenproject.org; Mon, 23 Dec 2019 15:17:51 +0000 Received: from mail-qt1-x82a.google.com (unknown [2607:f8b0:4864:20::82a]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 602dde54-2597-11ea-a1e1-bc764e2007e4; Mon, 23 Dec 2019 15:17:47 +0000 (UTC) Received: by mail-qt1-x82a.google.com with SMTP id l12so15610820qtq.12 for ; Mon, 23 Dec 2019 07:17:47 -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 u15sm5823907qku.67.2019.12.23.07.17.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 23 Dec 2019 07:17:45 -0800 (PST) X-Inumbo-ID: 602dde54-2597-11ea-a1e1-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=wsNbrXzTC4fbTgB0S7XOhOTybKwrAmTKHy13zlzg6dU=; b=hCNfW5Rxp00tKrKwd58mUjxr1ONqQ4ByU5C31vpw0/I993FU/kpbCxfgXIlo23qIef o0oLct4e73YsoQghYBFZJgQFUnQWqLHaqfkIKi3PI+ti9cTVZkz86HT2URuPKjCjS5FW Iz+dZMkm6J/Aw9eFa96dv5MXq29fH58LgSSAHhWPel3dDaMa/5wZhmZu2Lr3XDit0QeH sWpoSrZjKYMI2HUTiTlQK1maVkOoEmBtTJaLbnDZztGKpnjCqQjISFkImU2osVTqaxVf DspOEhTRht8y4yPwDgneXHlCgKKpDsOz0lDbAD7iRfD9ZZTucJE0FwfDPJKBkojyG7qJ bUow== 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=wsNbrXzTC4fbTgB0S7XOhOTybKwrAmTKHy13zlzg6dU=; b=IE8fEras6eRWPLRplnPO3HPtC3POLLJt3moEDvND+Z2UwTSg9/wVbm2S5uMCy+i6lA XV+anIuWhS0eNXV5gm0WetSEXJhjBQMSghY2knAI2gT/1P/grAvgGwZJZDZ2VF+n3Nwp zcc9ok4NR6Gzx4VIhVT0Ml9hG/jS32XU/426Xqg+LARHIL3p87kdK6OoxgdwJ6gwjDuS 1l0OkHhijYKIrlHoCHNMLP3A+4Az/pIEWEj2D/T0dqBWybT0gjIQlhakTFHhrEpmQv6V JyOTbfNzj6L9JN1U+MInVkWOngJ/xG1qH2coUrKoLtldyS3nl7jj64rT6EBuSUQCg7WJ Uo0g== X-Gm-Message-State: APjAAAXyW93Y50QOAglmiYObknZjgEMX8UreHd9BFwBV4xCJxGShIrdg hAZdf/N0RKXW6wUWqtN7soDZkXGE X-Google-Smtp-Source: APXvYqyesthus1zMDBZt2DD8FJFcib1HkmnRn/UtVS6to44Opf5crhRCJl3uDLeMQbL6SggCC1Bldg== X-Received: by 2002:ac8:787:: with SMTP id l7mr21833596qth.99.1577114266339; Mon, 23 Dec 2019 07:17:46 -0800 (PST) From: Nick Rosbrook X-Google-Original-From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Mon, 23 Dec 2019 10:17:02 -0500 Message-Id: X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Subject: [Xen-devel] [PATCH v4 1/6] golang/xenlight: implement array C to Go marshaling X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Nick Rosbrook , Ian Jackson , kerriganb@ainfosec.com, George Dunlap , Wei Liu 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 v4: - Call fromC using slice expression instead of creating temporary variable and assigning later. --- tools/golang/xenlight/gengotypes.py | 37 +++- tools/golang/xenlight/helpers.gen.go | 246 +++++++++++++++++++++++++++ 2 files changed, 282 insertions(+), 1 deletion(-) diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/ge= ngotypes.py index b68c1aa66b..8857e2e8fd 100644 --- a/tools/golang/xenlight/gengotypes.py +++ b/tools/golang/xenlight/gengotypes.py @@ -252,7 +252,7 @@ def xenlight_golang_define_from_C(ty =3D None): for f in ty.fields: if f.type.typename is not None: if isinstance(f.type, idl.Array): - # TODO + body +=3D xenlight_golang_array_from_C(f) continue =20 body +=3D xenlight_golang_convert_from_C(f) @@ -399,6 +399,41 @@ def xenlight_golang_union_from_C(ty =3D None, union_na= me =3D '', struct_name =3D ''): =20 return (s,extras) =20 +def xenlight_golang_array_from_C(ty =3D None): + """ + Convert C array to Go slice using the method + described here: + + https://github.com/golang/go/wiki/cgo#turning-c-arrays-into-go-slices + """ + s =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 + cslice =3D 'c{}'.format(goname) + clenvar =3D ty.type.lenvar.name + golenvar =3D xenlight_golang_fmt_name(clenvar,exported=3DFalse) + + s +=3D '{} :=3D int(xc.{})\n'.format(golenvar, clenvar) + s +=3D '{} :=3D '.format(cslice) + s +=3D'(*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.format(ctypena= me, cname, + golenvar, = golenvar) + s +=3D 'x.{} =3D make([]{}, {})\n'.format(goname, gotypename, golenvar) + s +=3D 'for i, v :=3D range {} {{\n'.format(cslice) + + is_enum =3D isinstance(ty.type.elem_type,idl.Enumeration) + if gotypename in go_builtin_types or is_enum: + s +=3D 'x.{}[i] =3D {}(v)\n'.format(goname, gotypename) + else: + s +=3D 'if err :=3D x.{}[i].fromC(&v); err !=3D nil {{\n'.format(g= oname) + s +=3D 'return err }\n' + + s +=3D '}\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 e6eee234c0..25294ba292 100644 --- a/tools/golang/xenlight/helpers.gen.go +++ b/tools/golang/xenlight/helpers.gen.go @@ -263,6 +263,14 @@ func (x *SchedParams) fromC(xc *C.libxl_sched_params) = error { =20 func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error { x.Sched =3D Scheduler(xc.sched) + numVcpus :=3D int(xc.num_vcpus) + cVcpus :=3D (*[1 << 28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:n= umVcpus:numVcpus] + x.Vcpus =3D make([]SchedParams, numVcpus) + for i, v :=3D range cVcpus { + if err :=3D x.Vcpus[i].fromC(&v); err !=3D nil { + return err + } + } =20 return nil } @@ -282,6 +290,12 @@ func (x *DomainSchedParams) fromC(xc *C.libxl_domain_s= ched_params) error { =20 func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error { x.Memkb =3D uint64(xc.memkb) + numDistances :=3D int(xc.num_distances) + cDistances :=3D (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.distances))[:num= Distances:numDistances] + x.Distances =3D make([]uint32, numDistances) + for i, v :=3D range cDistances { + x.Distances[i] =3D uint32(v) + } x.Pnode =3D uint32(xc.pnode) if err :=3D x.Vcpus.fromC(&xc.vcpus); err !=3D nil { return err @@ -308,6 +322,22 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_bui= ld_info) error { if err :=3D x.Nodemap.fromC(&xc.nodemap); err !=3D nil { return err } + numVcpuHardAffinity :=3D int(xc.num_vcpu_hard_affinity) + cVcpuHardAffinity :=3D (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_= hard_affinity))[:numVcpuHardAffinity:numVcpuHardAffinity] + x.VcpuHardAffinity =3D make([]Bitmap, numVcpuHardAffinity) + for i, v :=3D range cVcpuHardAffinity { + if err :=3D x.VcpuHardAffinity[i].fromC(&v); err !=3D nil { + return err + } + } + numVcpuSoftAffinity :=3D int(xc.num_vcpu_soft_affinity) + cVcpuSoftAffinity :=3D (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_= soft_affinity))[:numVcpuSoftAffinity:numVcpuSoftAffinity] + x.VcpuSoftAffinity =3D make([]Bitmap, numVcpuSoftAffinity) + for i, v :=3D range cVcpuSoftAffinity { + if err :=3D x.VcpuSoftAffinity[i].fromC(&v); err !=3D nil { + return err + } + } if err :=3D x.NumaPlacement.fromC(&xc.numa_placement); err !=3D nil { return err } @@ -330,6 +360,14 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_bui= ld_info) error { return err } x.BlkdevStart =3D C.GoString(xc.blkdev_start) + numVnumaNodes :=3D int(xc.num_vnuma_nodes) + cVnumaNodes :=3D (*[1 << 28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_n= odes))[:numVnumaNodes:numVnumaNodes] + x.VnumaNodes =3D make([]VnodeInfo, numVnumaNodes) + for i, v :=3D range cVnumaNodes { + if err :=3D x.VnumaNodes[i].fromC(&v); err !=3D nil { + return err + } + } x.MaxGrantFrames =3D uint32(xc.max_grant_frames) x.MaxMaptrackFrames =3D uint32(xc.max_maptrack_frames) x.DeviceModelVersion =3D DeviceModelVersion(xc.device_model_version) @@ -352,6 +390,28 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_bui= ld_info) error { if err :=3D x.SchedParams.fromC(&xc.sched_params); err !=3D nil { return err } + numIoports :=3D int(xc.num_ioports) + cIoports :=3D (*[1 << 28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports)= )[:numIoports:numIoports] + x.Ioports =3D make([]IoportRange, numIoports) + for i, v :=3D range cIoports { + if err :=3D x.Ioports[i].fromC(&v); err !=3D nil { + return err + } + } + numIrqs :=3D int(xc.num_irqs) + cIrqs :=3D (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:numIrqs:numIr= qs] + x.Irqs =3D make([]uint32, numIrqs) + for i, v :=3D range cIrqs { + x.Irqs[i] =3D uint32(v) + } + numIomem :=3D int(xc.num_iomem) + cIomem :=3D (*[1 << 28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:nu= mIomem:numIomem] + x.Iomem =3D make([]IomemRange, numIomem) + for i, v :=3D range cIomem { + if err :=3D x.Iomem[i].fromC(&v); err !=3D nil { + return err + } + } if err :=3D x.ClaimMode.fromC(&xc.claim_mode); err !=3D nil { return err } @@ -831,11 +891,31 @@ func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdisp= l) error { x.BackendDomname =3D C.GoString(xc.backend_domname) x.Devid =3D Devid(xc.devid) x.BeAlloc =3D bool(xc.be_alloc) + numConnectors :=3D int(xc.num_connectors) + cConnectors :=3D (*[1 << 28]C.libxl_connector_param)(unsafe.Pointer(xc.co= nnectors))[:numConnectors:numConnectors] + x.Connectors =3D make([]ConnectorParam, numConnectors) + for i, v :=3D range cConnectors { + if err :=3D x.Connectors[i].fromC(&v); err !=3D nil { + return err + } + } =20 return nil } =20 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] + x.SampleRates =3D make([]uint32, numSampleRates) + for i, v :=3D range cSampleRates { + x.SampleRates[i] =3D uint32(v) + } + numSampleFormats :=3D int(xc.num_sample_formats) + cSampleFormats :=3D (*[1 << 28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc= .sample_formats))[:numSampleFormats:numSampleFormats] + x.SampleFormats =3D make([]VsndPcmFormat, numSampleFormats) + for i, v :=3D range cSampleFormats { + x.SampleFormats[i] =3D VsndPcmFormat(v) + } x.ChannelsMin =3D uint32(xc.channels_min) x.ChannelsMax =3D uint32(xc.channels_max) x.BufferSize =3D uint32(xc.buffer_size) @@ -858,6 +938,14 @@ func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error { if err :=3D x.Params.fromC(&xc.params); err !=3D nil { return err } + numVsndStreams :=3D int(xc.num_vsnd_streams) + cStreams :=3D (*[1 << 28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams))= [:numVsndStreams:numVsndStreams] + x.Streams =3D make([]VsndStream, numVsndStreams) + for i, v :=3D range cStreams { + if err :=3D x.Streams[i].fromC(&v); err !=3D nil { + return err + } + } =20 return nil } @@ -871,6 +959,14 @@ func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) er= ror { if err :=3D x.Params.fromC(&xc.params); err !=3D nil { return err } + numVsndPcms :=3D int(xc.num_vsnd_pcms) + cPcms :=3D (*[1 << 28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:numVsnd= Pcms:numVsndPcms] + x.Pcms =3D make([]VsndPcm, numVsndPcms) + for i, v :=3D range cPcms { + if err :=3D x.Pcms[i].fromC(&v); err !=3D nil { + return err + } + } =20 return nil } @@ -882,6 +978,126 @@ func (x *DomainConfig) fromC(xc *C.libxl_domain_confi= g) error { if err :=3D x.BInfo.fromC(&xc.b_info); err !=3D nil { return err } + numDisks :=3D int(xc.num_disks) + cDisks :=3D (*[1 << 28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:nu= mDisks:numDisks] + x.Disks =3D make([]DeviceDisk, numDisks) + for i, v :=3D range cDisks { + if err :=3D x.Disks[i].fromC(&v); err !=3D nil { + return err + } + } + numNics :=3D int(xc.num_nics) + cNics :=3D (*[1 << 28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:numNi= cs:numNics] + x.Nics =3D make([]DeviceNic, numNics) + for i, v :=3D range cNics { + if err :=3D x.Nics[i].fromC(&v); err !=3D nil { + return err + } + } + numPcidevs :=3D int(xc.num_pcidevs) + cPcidevs :=3D (*[1 << 28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))[= :numPcidevs:numPcidevs] + x.Pcidevs =3D make([]DevicePci, numPcidevs) + for i, v :=3D range cPcidevs { + if err :=3D x.Pcidevs[i].fromC(&v); err !=3D nil { + return err + } + } + numRdms :=3D int(xc.num_rdms) + cRdms :=3D (*[1 << 28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:numRd= ms:numRdms] + x.Rdms =3D make([]DeviceRdm, numRdms) + for i, v :=3D range cRdms { + if err :=3D x.Rdms[i].fromC(&v); err !=3D nil { + return err + } + } + numDtdevs :=3D int(xc.num_dtdevs) + cDtdevs :=3D (*[1 << 28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))[= :numDtdevs:numDtdevs] + x.Dtdevs =3D make([]DeviceDtdev, numDtdevs) + for i, v :=3D range cDtdevs { + if err :=3D x.Dtdevs[i].fromC(&v); err !=3D nil { + return err + } + } + numVfbs :=3D int(xc.num_vfbs) + cVfbs :=3D (*[1 << 28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:numVf= bs:numVfbs] + x.Vfbs =3D make([]DeviceVfb, numVfbs) + for i, v :=3D range cVfbs { + if err :=3D x.Vfbs[i].fromC(&v); err !=3D nil { + return err + } + } + numVkbs :=3D int(xc.num_vkbs) + cVkbs :=3D (*[1 << 28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:numVk= bs:numVkbs] + x.Vkbs =3D make([]DeviceVkb, numVkbs) + for i, v :=3D range cVkbs { + if err :=3D x.Vkbs[i].fromC(&v); err !=3D nil { + return err + } + } + numVtpms :=3D int(xc.num_vtpms) + cVtpms :=3D (*[1 << 28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:nu= mVtpms:numVtpms] + x.Vtpms =3D make([]DeviceVtpm, numVtpms) + for i, v :=3D range cVtpms { + if err :=3D x.Vtpms[i].fromC(&v); err !=3D nil { + return err + } + } + numP9S :=3D int(xc.num_p9s) + cP9S :=3D (*[1 << 28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:numP9S:n= umP9S] + x.P9S =3D make([]DeviceP9, numP9S) + for i, v :=3D range cP9S { + if err :=3D x.P9S[i].fromC(&v); err !=3D nil { + return err + } + } + numPvcallsifs :=3D int(xc.num_pvcallsifs) + cPvcallsifs :=3D (*[1 << 28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.p= vcallsifs))[:numPvcallsifs:numPvcallsifs] + x.Pvcallsifs =3D make([]DevicePvcallsif, numPvcallsifs) + for i, v :=3D range cPvcallsifs { + if err :=3D x.Pvcallsifs[i].fromC(&v); err !=3D nil { + return err + } + } + numVdispls :=3D int(xc.num_vdispls) + cVdispls :=3D (*[1 << 28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispls= ))[:numVdispls:numVdispls] + x.Vdispls =3D make([]DeviceVdispl, numVdispls) + for i, v :=3D range cVdispls { + if err :=3D x.Vdispls[i].fromC(&v); err !=3D nil { + return err + } + } + numVsnds :=3D int(xc.num_vsnds) + cVsnds :=3D (*[1 << 28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:nu= mVsnds:numVsnds] + x.Vsnds =3D make([]DeviceVsnd, numVsnds) + for i, v :=3D range cVsnds { + if err :=3D x.Vsnds[i].fromC(&v); err !=3D nil { + return err + } + } + numChannels :=3D int(xc.num_channels) + cChannels :=3D (*[1 << 28]C.libxl_device_channel)(unsafe.Pointer(xc.chann= els))[:numChannels:numChannels] + x.Channels =3D make([]DeviceChannel, numChannels) + for i, v :=3D range cChannels { + if err :=3D x.Channels[i].fromC(&v); err !=3D nil { + return err + } + } + numUsbctrls :=3D int(xc.num_usbctrls) + cUsbctrls :=3D (*[1 << 28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbct= rls))[:numUsbctrls:numUsbctrls] + x.Usbctrls =3D make([]DeviceUsbctrl, numUsbctrls) + for i, v :=3D range cUsbctrls { + if err :=3D x.Usbctrls[i].fromC(&v); err !=3D nil { + return err + } + } + numUsbdevs :=3D int(xc.num_usbdevs) + cUsbdevs :=3D (*[1 << 28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdevs= ))[:numUsbdevs:numUsbdevs] + x.Usbdevs =3D make([]DeviceUsbdev, numUsbdevs) + for i, v :=3D range cUsbdevs { + if err :=3D x.Usbdevs[i].fromC(&v); err !=3D nil { + return err + } + } x.OnPoweroff =3D ActionOnShutdown(xc.on_poweroff) x.OnReboot =3D ActionOnShutdown(xc.on_reboot) x.OnWatchdog =3D ActionOnShutdown(xc.on_watchdog) @@ -1015,6 +1231,14 @@ func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) e= rror { x.Devid =3D Devid(xc.devid) x.State =3D int(xc.state) x.BeAlloc =3D bool(xc.be_alloc) + numConnectors :=3D int(xc.num_connectors) + cConnectors :=3D (*[1 << 28]C.libxl_connectorinfo)(unsafe.Pointer(xc.conn= ectors))[:numConnectors:numConnectors] + x.Connectors =3D make([]Connectorinfo, numConnectors) + for i, v :=3D range cConnectors { + if err :=3D x.Connectors[i].fromC(&v); err !=3D nil { + return err + } + } =20 return nil } @@ -1027,6 +1251,14 @@ func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) e= rror { } =20 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] + x.Streams =3D make([]Streaminfo, numVsndStreams) + for i, v :=3D range cStreams { + if err :=3D x.Streams[i].fromC(&v); err !=3D nil { + return err + } + } =20 return nil } @@ -1038,6 +1270,14 @@ func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error= { x.FrontendId =3D uint32(xc.frontend_id) x.Devid =3D Devid(xc.devid) x.State =3D int(xc.state) + numVsndPcms :=3D int(xc.num_vsnd_pcms) + cPcms :=3D (*[1 << 28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:numVsndP= cms:numVsndPcms] + x.Pcms =3D make([]Pcminfo, numVsndPcms) + for i, v :=3D range cPcms { + if err :=3D x.Pcms[i].fromC(&v); err !=3D nil { + return err + } + } =20 return nil } @@ -1058,6 +1298,12 @@ func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error { func (x *Numainfo) fromC(xc *C.libxl_numainfo) error { x.Size =3D uint64(xc.size) x.Free =3D uint64(xc.free) + numDists :=3D int(xc.num_dists) + cDists :=3D (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.dists))[:numDists:nu= mDists] + x.Dists =3D make([]uint32, numDists) + for i, v :=3D range cDists { + x.Dists[i] =3D uint32(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 From nobody Tue May 7 14:51:30 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=1577114389; cv=none; d=zohomail.com; s=zohoarc; b=ETJd0dcLn/2tVc5XJomdjIhSV64MfKpu+esDEA7AAIUHv/49UzWh38F/P7iI5jsn9SLJ1YEsMcgrpXHp/tv0h6FAAmlulRQPkprWyy1bpQno57LkJ1LlKHkftikRwdLwNrT1o7A3f+qYBR0aQ3YhJh5lma1zlQSb9/KSPGKBMUM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1577114389; 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=hYCdM3qxG1/6U1V68Um4FqDbRgCXnf4mNpY4uLvRigQ=; b=BCuExt22c/jrvHMo928e3p8kbO9LaE+ZKRQvKgvJHPz8P/+7XaS5Ka7UjDoALcWQo2Skifbv9GAR0fX11BrGFk+3Tn8rv2uuW3oaHaoeWCp3/0cc9LSnmvS+/b7J/bptNMonJauo5e5GehlmUwNEBpMpbixzi0ecfDKLjnr3Akg= 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 1577114389737799.9163351774648; Mon, 23 Dec 2019 07:19:49 -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 1ijPT3-0006KH-AU; Mon, 23 Dec 2019 15:17:57 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1ijPT2-0006KA-I1 for xen-devel@lists.xenproject.org; Mon, 23 Dec 2019 15:17:56 +0000 Received: from mail-qt1-x835.google.com (unknown [2607:f8b0:4864:20::835]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 61ae7b80-2597-11ea-b6f1-bc764e2007e4; Mon, 23 Dec 2019 15:17:49 +0000 (UTC) Received: by mail-qt1-x835.google.com with SMTP id j5so15624423qtq.9 for ; Mon, 23 Dec 2019 07:17:49 -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 u15sm5823907qku.67.2019.12.23.07.17.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 23 Dec 2019 07:17:47 -0800 (PST) X-Inumbo-ID: 61ae7b80-2597-11ea-b6f1-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=BdM7Aa9ODykWX2XVW3cQ+dGYhtK+6pwO9eA+HlT05yk=; b=n0c65eRRIn9A+De1j8SevSoUI5aHs41RezoU/DUwz+O7dRP5rQ0hWB37y58dBM1K9m nFppgqEQUoOy/okfEObY2Bq+oFVRICU4m1ks616c+3mAoIn3Cq/mnmoSsYkgbmlIzjXd UAYska63g7WOpw1pGCU+o5WjYKl7GiZyaDJzfuesRYEsHEqccp+ksWTFNjOsns8uKyRD tJnMy9QJBR81wOEkBf5V582+MmLutJYFNk9F7+Fxl/P6JPA4AlE1W5fCBLSslJDQSDnw pOg2Q9ePxs5KSfQR5CO60FAR0AMsPQxSIycfxey3Gi21HiXdJ9t0M7mI+Q0gXvlKcZ3Q 55Vg== 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=BdM7Aa9ODykWX2XVW3cQ+dGYhtK+6pwO9eA+HlT05yk=; b=R3ov3S6WA7WcfEe4wu3JrfAPDGEUAp4Z3WWnywVEggK9GuKsTRcgn/TMA/258W9kx+ BlDZvZWIOXCIfGMRJegXlChUKNiUn4/ZWgYQbgN2DQF1jiOJpbm1274TfzmnZCp5EdR/ GQAkAPDc/GQjDwdv7yu/BQDm+aCAQwcA4vJ2C0DzwlGp/OSwBJ9SG1w5/fbQD3QdYIka HW+I/0MyVVaLd/2+OtJRk32fisSwjYfjFxo5SBSnbF32OERprdccj5/6G7/Wg9rW6Xxv q+ssMu+OATcytLVrlrp36raRnt3ynCGiFAwMm0w9i751LQhmSaF9dyBZzLNe+njZwuwR S1JA== X-Gm-Message-State: APjAAAXnVTOzsDvqxyanxjqwIniotCDEFTJdLRH4aXcJneqw0bEc8T3h O5oaRe8VHpKvsIjbr7z7A46SW5A8 X-Google-Smtp-Source: APXvYqzRgre0HLcQgxwq8M6zlA4eshPzVIx03Lrl1/O8WiPTioiiPcpUwj4/9RAbUNmX07Yaimieyw== X-Received: by 2002:ac8:1e8e:: with SMTP id c14mr21595805qtm.330.1577114268116; Mon, 23 Dec 2019 07:17:48 -0800 (PST) From: Nick Rosbrook X-Google-Original-From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Mon, 23 Dec 2019 10:17:03 -0500 Message-Id: <8b574d23f6abfc5356b65c958f637f3c22be5d9d.1577111872.git.rosbrookn@ainfosec.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Subject: [Xen-devel] [PATCH v4 2/6] 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 , kerriganb@ainfosec.com, 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 conversion of basic type conversions such as strings and integer types in toC functions. Signed-off-by: Nick Rosbrook --- tools/golang/xenlight/gengotypes.py | 80 ++ tools/golang/xenlight/helpers.gen.go | 1015 ++++++++++++++++++++++++++ 2 files changed, 1095 insertions(+) diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/ge= ngotypes.py index 8857e2e8fd..9d5f8300a2 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,83 @@ 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): + s =3D '' + + gotypename =3D ctypename =3D '' + + if typename is not None: + gotypename =3D xenlight_golang_fmt_name(typename) + ctypename =3D typename + else: + gotypename =3D xenlight_golang_fmt_name(ty.typename) + ctypename =3D ty.typename + + if not nested: + s +=3D 'func (x *{}) toC() (xc C.{},err error) {{\n'.format(gotype= name,ctypename) + s +=3D 'C.{}(&xc)\n'.format(ty.init_fn) + + for f in ty.fields: + if f.type.typename is not None: + if isinstance(f.type, idl.Array): + # TODO + continue + + gotypename =3D xenlight_golang_fmt_name(f.type.typename) + ctypename =3D f.type.typename + gofname =3D xenlight_golang_fmt_name(f.name) + cfname =3D f.name + + # In cgo, C names that conflict with Go keywords can be + # accessed by prepending an underscore to the name. + if cfname in go_keywords: + cfname =3D '_' + cfname + + # If this is nested, we need the outer name too. + if nested and typename is not None: + goname =3D xenlight_golang_fmt_name(typename) + goname =3D '{}.{}'.format(goname, gofname) + cname =3D '{}.{}'.format(typename, cfname) + + else: + goname =3D gofname + cname =3D cfname + + is_castable =3D (f.type.json_parse_type =3D=3D 'JSON_INTEGER' = or + isinstance(f.type, idl.Enumeration) or + gotypename in go_builtin_types) + + if is_castable: + # Use the cgo helper for converting C strings. + if gotypename =3D=3D 'string': + s +=3D 'xc.{} =3D C.CString(x.{})\n'.format(cname,gona= me) + continue + + s +=3D 'xc.{} =3D C.{}(x.{})\n'.format(cname,ctypename,gon= ame) + + else: + s +=3D 'xc.{}, err =3D x.{}.toC()\n'.format(cname,goname) + s +=3D 'if err !=3D nil {\n' + s +=3D 'C.{}(&xc)\n'.format(ty.dispose_fn) + s +=3D 'return xc, err\n' + s +=3D '}\n' + + elif isinstance(f.type, idl.Struct): + s +=3D xenlight_golang_define_to_C(f.type, typename=3Df.name, = nested=3DTrue) + + elif isinstance(f.type, idl.KeyedUnion): + # TODO + pass + + else: + raise Exception('type {} not supported'.format(f.type)) + + if not nested: + s +=3D 'return xc, nil' + s +=3D '}\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 25294ba292..be80d6c718 100644 --- a/tools/golang/xenlight/helpers.gen.go +++ b/tools/golang/xenlight/helpers.gen.go @@ -37,6 +37,13 @@ func (x *IoportRange) fromC(xc *C.libxl_ioport_range) er= ror { return nil } =20 +func (x *IoportRange) toC() (xc C.libxl_ioport_range, err error) { + C.libxl_ioport_range_init(&xc) + xc.first =3D C.uint32_t(x.First) + xc.number =3D C.uint32_t(x.Number) + return xc, 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 +52,26 @@ 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) { + C.libxl_iomem_range_init(&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 xc, 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= ) { + C.libxl_vga_interface_info_init(&xc) + xc.kind =3D C.libxl_vga_interface_type(x.Kind) + return xc, 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 +86,24 @@ func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error { return nil } =20 +func (x *VncInfo) toC() (xc C.libxl_vnc_info, err error) { + C.libxl_vnc_info_init(&xc) + xc.enable, err =3D x.Enable.toC() + if err !=3D nil { + C.libxl_vnc_info_dispose(&xc) + return xc, err + } + xc.listen =3D C.CString(x.Listen) + xc.passwd =3D C.CString(x.Passwd) + xc.display =3D C.int(x.Display) + xc.findunused, err =3D x.Findunused.toC() + if err !=3D nil { + C.libxl_vnc_info_dispose(&xc) + return xc, err + } + return xc, nil +} + func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error { if err :=3D x.Enable.fromC(&xc.enable); err !=3D nil { return err @@ -92,6 +131,43 @@ func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error= { return nil } =20 +func (x *SpiceInfo) toC() (xc C.libxl_spice_info, err error) { + C.libxl_spice_info_init(&xc) + xc.enable, err =3D x.Enable.toC() + if err !=3D nil { + C.libxl_spice_info_dispose(&xc) + return xc, err + } + xc.port =3D C.int(x.Port) + xc.tls_port =3D C.int(x.TlsPort) + xc.host =3D C.CString(x.Host) + xc.disable_ticketing, err =3D x.DisableTicketing.toC() + if err !=3D nil { + C.libxl_spice_info_dispose(&xc) + return xc, err + } + xc.passwd =3D C.CString(x.Passwd) + xc.agent_mouse, err =3D x.AgentMouse.toC() + if err !=3D nil { + C.libxl_spice_info_dispose(&xc) + return xc, err + } + xc.vdagent, err =3D x.Vdagent.toC() + if err !=3D nil { + C.libxl_spice_info_dispose(&xc) + return xc, err + } + xc.clipboard_sharing, err =3D x.ClipboardSharing.toC() + if err !=3D nil { + C.libxl_spice_info_dispose(&xc) + return xc, err + } + xc.usbredirection =3D C.int(x.Usbredirection) + xc.image_compression =3D C.CString(x.ImageCompression) + xc.streaming_video =3D C.CString(x.StreamingVideo) + return xc, 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 +181,23 @@ func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error { return nil } =20 +func (x *SdlInfo) toC() (xc C.libxl_sdl_info, err error) { + C.libxl_sdl_info_init(&xc) + xc.enable, err =3D x.Enable.toC() + if err !=3D nil { + C.libxl_sdl_info_dispose(&xc) + return xc, err + } + xc.opengl, err =3D x.Opengl.toC() + if err !=3D nil { + C.libxl_sdl_info_dispose(&xc) + return xc, err + } + xc.display =3D C.CString(x.Display) + xc.xauthority =3D C.CString(x.Xauthority) + return xc, 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 +226,36 @@ func (x *Dominfo) fromC(xc *C.libxl_dominfo) error { return nil } =20 +func (x *Dominfo) toC() (xc C.libxl_dominfo, err error) { + C.libxl_dominfo_init(&xc) + xc.uuid, err =3D x.Uuid.toC() + if err !=3D nil { + C.libxl_dominfo_dispose(&xc) + return xc, err + } + xc.domid =3D C.libxl_domid(x.Domid) + xc.ssidref =3D C.uint32_t(x.Ssidref) + 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 xc, 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 +268,20 @@ func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) e= rror { return nil } =20 +func (x *Cpupoolinfo) toC() (xc C.libxl_cpupoolinfo, err error) { + C.libxl_cpupoolinfo_init(&xc) + xc.poolid =3D C.uint32_t(x.Poolid) + 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) + xc.cpumap, err =3D x.Cpumap.toC() + if err !=3D nil { + C.libxl_cpupoolinfo_dispose(&xc) + return xc, err + } + return xc, 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 +316,19 @@ func (x *ChannelinfoConnectionUnionPty) fromC(xc *C.li= bxl_channelinfo) error { return nil } =20 +func (x *Channelinfo) toC() (xc C.libxl_channelinfo, err error) { + C.libxl_channelinfo_init(&xc) + xc.backend =3D C.CString(x.Backend) + xc.backend_id =3D C.uint32_t(x.BackendId) + 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 xc, 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 +338,17 @@ func (x *Vminfo) fromC(xc *C.libxl_vminfo) error { return nil } =20 +func (x *Vminfo) toC() (xc C.libxl_vminfo, err error) { + C.libxl_vminfo_init(&xc) + xc.uuid, err =3D x.Uuid.toC() + if err !=3D nil { + C.libxl_vminfo_dispose(&xc) + return xc, err + } + xc.domid =3D C.libxl_domid(x.Domid) + return xc, 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 +367,24 @@ func (x *VersionInfo) fromC(xc *C.libxl_version_info) = error { return nil } =20 +func (x *VersionInfo) toC() (xc C.libxl_version_info, err error) { + C.libxl_version_info_init(&xc) + xc.xen_version_major =3D C.int(x.XenVersionMajor) + xc.xen_version_minor =3D C.int(x.XenVersionMinor) + xc.xen_version_extra =3D C.CString(x.XenVersionExtra) + xc.compiler =3D C.CString(x.Compiler) + xc.compile_by =3D C.CString(x.CompileBy) + xc.compile_domain =3D C.CString(x.CompileDomain) + xc.compile_date =3D C.CString(x.CompileDate) + xc.capabilities =3D C.CString(x.Capabilities) + xc.changeset =3D C.CString(x.Changeset) + xc.virt_start =3D C.uint64_t(x.VirtStart) + xc.pagesize =3D C.int(x.Pagesize) + xc.commandline =3D C.CString(x.Commandline) + xc.build_id =3D C.CString(x.BuildId) + return xc, 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 +418,53 @@ 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= ) { + C.libxl_domain_create_info_init(&xc) + xc._type =3D C.libxl_domain_type(x.Type) + xc.hap, err =3D x.Hap.toC() + if err !=3D nil { + C.libxl_domain_create_info_dispose(&xc) + return xc, err + } + xc.oos, err =3D x.Oos.toC() + if err !=3D nil { + C.libxl_domain_create_info_dispose(&xc) + return xc, err + } + xc.ssidref =3D C.uint32_t(x.Ssidref) + xc.ssid_label =3D C.CString(x.SsidLabel) + xc.name =3D C.CString(x.Name) + xc.uuid, err =3D x.Uuid.toC() + if err !=3D nil { + C.libxl_domain_create_info_dispose(&xc) + return xc, err + } + xc.xsdata, err =3D x.Xsdata.toC() + if err !=3D nil { + C.libxl_domain_create_info_dispose(&xc) + return xc, err + } + xc.platformdata, err =3D x.Platformdata.toC() + if err !=3D nil { + C.libxl_domain_create_info_dispose(&xc) + return xc, err + } + xc.poolid =3D C.uint32_t(x.Poolid) + xc.pool_name =3D C.CString(x.PoolName) + xc.run_hotplug_scripts, err =3D x.RunHotplugScripts.toC() + if err !=3D nil { + C.libxl_domain_create_info_dispose(&xc) + return xc, err + } + xc.driver_domain, err =3D x.DriverDomain.toC() + if err !=3D nil { + C.libxl_domain_create_info_dispose(&xc) + return xc, err + } + xc.passthrough =3D C.libxl_passthrough(x.Passthrough) + return xc, 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 +476,19 @@ 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) { + C.libxl_domain_restore_params_init(&xc) + xc.checkpointed_stream =3D C.int(x.CheckpointedStream) + xc.stream_version =3D C.uint32_t(x.StreamVersion) + xc.colo_proxy_script =3D C.CString(x.ColoProxyScript) + xc.userspace_colo_proxy, err =3D x.UserspaceColoProxy.toC() + if err !=3D nil { + C.libxl_domain_restore_params_dispose(&xc) + return xc, err + } + return xc, nil +} + func (x *SchedParams) fromC(xc *C.libxl_sched_params) error { x.Vcpuid =3D int(xc.vcpuid) x.Weight =3D int(xc.weight) @@ -261,6 +500,17 @@ func (x *SchedParams) fromC(xc *C.libxl_sched_params) = error { return nil } =20 +func (x *SchedParams) toC() (xc C.libxl_sched_params, err error) { + C.libxl_sched_params_init(&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 xc, 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 +525,12 @@ 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) { + C.libxl_vcpu_sched_params_init(&xc) + xc.sched =3D C.libxl_scheduler(x.Sched) + return xc, 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 +544,19 @@ 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 err= or) { + C.libxl_domain_sched_params_init(&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 xc, 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 +573,18 @@ 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) { + C.libxl_vnode_info_init(&xc) + xc.memkb =3D C.uint64_t(x.Memkb) + xc.pnode =3D C.uint32_t(x.Pnode) + xc.vcpus, err =3D x.Vcpus.toC() + if err !=3D nil { + C.libxl_vnode_info_dispose(&xc) + return xc, err + } + return xc, nil +} + func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) error { x.Strategy =3D RdmReserveStrategy(xc.strategy) x.Policy =3D RdmReservePolicy(xc.policy) @@ -311,6 +592,13 @@ 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) { + C.libxl_rdm_reserve_init(&xc) + xc.strategy =3D C.libxl_rdm_reserve_strategy(x.Strategy) + xc.policy =3D C.libxl_rdm_reserve_policy(x.Policy) + return xc, 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 +901,130 @@ func (x *DomainBuildInfoTypeUnionPvh) fromC(xc *C.lib= xl_domain_build_info) error return nil } =20 +func (x *DomainBuildInfo) toC() (xc C.libxl_domain_build_info, err error) { + C.libxl_domain_build_info_init(&xc) + xc.max_vcpus =3D C.int(x.MaxVcpus) + xc.avail_vcpus, err =3D x.AvailVcpus.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.cpumap, err =3D x.Cpumap.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.nodemap, err =3D x.Nodemap.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.numa_placement, err =3D x.NumaPlacement.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, 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) + xc.exec_ssid_label =3D C.CString(x.ExecSsidLabel) + xc.localtime, err =3D x.Localtime.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.disable_migrate, err =3D x.DisableMigrate.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.cpuid, err =3D x.Cpuid.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + 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) + xc.device_model_stubdomain, err =3D x.DeviceModelStubdomain.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.device_model =3D C.CString(x.DeviceModel) + xc.device_model_ssidref =3D C.uint32_t(x.DeviceModelSsidref) + xc.device_model_ssid_label =3D C.CString(x.DeviceModelSsidLabel) + xc.device_model_user =3D C.CString(x.DeviceModelUser) + xc.extra, err =3D x.Extra.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.extra_pv, err =3D x.ExtraPv.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.extra_hvm, err =3D x.ExtraHvm.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.sched_params, err =3D x.SchedParams.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.claim_mode, err =3D x.ClaimMode.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.event_channels =3D C.uint32_t(x.EventChannels) + xc.kernel =3D C.CString(x.Kernel) + xc.cmdline =3D C.CString(x.Cmdline) + xc.ramdisk =3D C.CString(x.Ramdisk) + xc.device_tree =3D C.CString(x.DeviceTree) + xc.acpi, err =3D x.Acpi.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.bootloader =3D C.CString(x.Bootloader) + xc.bootloader_args, err =3D x.BootloaderArgs.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.timer_mode =3D C.libxl_timer_mode(x.TimerMode) + xc.nested_hvm, err =3D x.NestedHvm.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.apic, err =3D x.Apic.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + xc.dm_restrict, err =3D x.DmRestrict.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, 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 xc, 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 +1040,25 @@ 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) { + C.libxl_device_vfb_init(&xc) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + xc.backend_domname =3D C.CString(x.BackendDomname) + xc.devid =3D C.libxl_devid(x.Devid) + xc.vnc, err =3D x.Vnc.toC() + if err !=3D nil { + C.libxl_device_vfb_dispose(&xc) + return xc, err + } + xc.sdl, err =3D x.Sdl.toC() + if err !=3D nil { + C.libxl_device_vfb_dispose(&xc) + return xc, err + } + xc.keymap =3D C.CString(x.Keymap) + return xc, 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 +1079,26 @@ 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) { + C.libxl_device_vkb_init(&xc) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + 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) + 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 xc, 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 +1129,42 @@ 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) { + C.libxl_device_disk_init(&xc) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + xc.backend_domname =3D C.CString(x.BackendDomname) + xc.pdev_path =3D C.CString(x.PdevPath) + 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) + 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) + xc.discard_enable, err =3D x.DiscardEnable.toC() + if err !=3D nil { + C.libxl_device_disk_dispose(&xc) + return xc, err + } + xc.colo_enable, err =3D x.ColoEnable.toC() + if err !=3D nil { + C.libxl_device_disk_dispose(&xc) + return xc, err + } + xc.colo_restore_enable, err =3D x.ColoRestoreEnable.toC() + if err !=3D nil { + C.libxl_device_disk_dispose(&xc) + return xc, err + } + xc.colo_host =3D C.CString(x.ColoHost) + xc.colo_port =3D C.int(x.ColoPort) + xc.colo_export =3D C.CString(x.ColoExport) + xc.active_disk =3D C.CString(x.ActiveDisk) + xc.hidden_disk =3D C.CString(x.HiddenDisk) + return xc, 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 +1235,78 @@ func (x *DeviceNic) fromC(xc *C.libxl_device_nic) err= or { return nil } =20 +func (x *DeviceNic) toC() (xc C.libxl_device_nic, err error) { + C.libxl_device_nic_init(&xc) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + xc.backend_domname =3D C.CString(x.BackendDomname) + xc.devid =3D C.libxl_devid(x.Devid) + xc.mtu =3D C.int(x.Mtu) + xc.model =3D C.CString(x.Model) + xc.mac, err =3D x.Mac.toC() + if err !=3D nil { + C.libxl_device_nic_dispose(&xc) + return xc, err + } + xc.ip =3D C.CString(x.Ip) + xc.bridge =3D C.CString(x.Bridge) + xc.ifname =3D C.CString(x.Ifname) + 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) + xc.gatewaydev =3D C.CString(x.Gatewaydev) + xc.coloft_forwarddev =3D C.CString(x.ColoftForwarddev) + xc.colo_sock_mirror_id =3D C.CString(x.ColoSockMirrorId) + xc.colo_sock_mirror_ip =3D C.CString(x.ColoSockMirrorIp) + xc.colo_sock_mirror_port =3D C.CString(x.ColoSockMirrorPort) + xc.colo_sock_compare_pri_in_id =3D C.CString(x.ColoSockComparePriInId) + xc.colo_sock_compare_pri_in_ip =3D C.CString(x.ColoSockComparePriInIp) + xc.colo_sock_compare_pri_in_port =3D C.CString(x.ColoSockComparePriInPort) + xc.colo_sock_compare_sec_in_id =3D C.CString(x.ColoSockCompareSecInId) + xc.colo_sock_compare_sec_in_ip =3D C.CString(x.ColoSockCompareSecInIp) + xc.colo_sock_compare_sec_in_port =3D C.CString(x.ColoSockCompareSecInPort) + xc.colo_sock_compare_notify_id =3D C.CString(x.ColoSockCompareNotifyId) + xc.colo_sock_compare_notify_ip =3D C.CString(x.ColoSockCompareNotifyIp) + xc.colo_sock_compare_notify_port =3D C.CString(x.ColoSockCompareNotifyPor= t) + xc.colo_sock_redirector0_id =3D C.CString(x.ColoSockRedirector0Id) + xc.colo_sock_redirector0_ip =3D C.CString(x.ColoSockRedirector0Ip) + xc.colo_sock_redirector0_port =3D C.CString(x.ColoSockRedirector0Port) + xc.colo_sock_redirector1_id =3D C.CString(x.ColoSockRedirector1Id) + xc.colo_sock_redirector1_ip =3D C.CString(x.ColoSockRedirector1Ip) + xc.colo_sock_redirector1_port =3D C.CString(x.ColoSockRedirector1Port) + xc.colo_sock_redirector2_id =3D C.CString(x.ColoSockRedirector2Id) + xc.colo_sock_redirector2_ip =3D C.CString(x.ColoSockRedirector2Ip) + xc.colo_sock_redirector2_port =3D C.CString(x.ColoSockRedirector2Port) + xc.colo_filter_mirror_queue =3D C.CString(x.ColoFilterMirrorQueue) + xc.colo_filter_mirror_outdev =3D C.CString(x.ColoFilterMirrorOutdev) + xc.colo_filter_redirector0_queue =3D C.CString(x.ColoFilterRedirector0Que= ue) + xc.colo_filter_redirector0_indev =3D C.CString(x.ColoFilterRedirector0Ind= ev) + xc.colo_filter_redirector0_outdev =3D C.CString(x.ColoFilterRedirector0Ou= tdev) + xc.colo_filter_redirector1_queue =3D C.CString(x.ColoFilterRedirector1Que= ue) + xc.colo_filter_redirector1_indev =3D C.CString(x.ColoFilterRedirector1Ind= ev) + xc.colo_filter_redirector1_outdev =3D C.CString(x.ColoFilterRedirector1Ou= tdev) + xc.colo_compare_pri_in =3D C.CString(x.ColoComparePriIn) + xc.colo_compare_sec_in =3D C.CString(x.ColoCompareSecIn) + xc.colo_compare_out =3D C.CString(x.ColoCompareOut) + xc.colo_compare_notify_dev =3D C.CString(x.ColoCompareNotifyDev) + xc.colo_sock_sec_redirector0_id =3D C.CString(x.ColoSockSecRedirector0Id) + xc.colo_sock_sec_redirector0_ip =3D C.CString(x.ColoSockSecRedirector0Ip) + xc.colo_sock_sec_redirector0_port =3D C.CString(x.ColoSockSecRedirector0P= ort) + xc.colo_sock_sec_redirector1_id =3D C.CString(x.ColoSockSecRedirector1Id) + xc.colo_sock_sec_redirector1_ip =3D C.CString(x.ColoSockSecRedirector1Ip) + xc.colo_sock_sec_redirector1_port =3D C.CString(x.ColoSockSecRedirector1P= ort) + xc.colo_filter_sec_redirector0_queue =3D C.CString(x.ColoFilterSecRedirec= tor0Queue) + xc.colo_filter_sec_redirector0_indev =3D C.CString(x.ColoFilterSecRedirec= tor0Indev) + xc.colo_filter_sec_redirector0_outdev =3D C.CString(x.ColoFilterSecRedire= ctor0Outdev) + xc.colo_filter_sec_redirector1_queue =3D C.CString(x.ColoFilterSecRedirec= tor1Queue) + xc.colo_filter_sec_redirector1_indev =3D C.CString(x.ColoFilterSecRedirec= tor1Indev) + xc.colo_filter_sec_redirector1_outdev =3D C.CString(x.ColoFilterSecRedire= ctor1Outdev) + xc.colo_filter_sec_rewriter0_queue =3D C.CString(x.ColoFilterSecRewriter0= Queue) + xc.colo_checkpoint_host =3D C.CString(x.ColoCheckpointHost) + xc.colo_checkpoint_port =3D C.CString(x.ColoCheckpointPort) + return xc, 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 +1323,22 @@ 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) { + C.libxl_device_pci_init(&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 xc, 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 +1347,14 @@ 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) { + C.libxl_device_rdm_init(&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 xc, 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 +1366,17 @@ 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) { + C.libxl_device_usbctrl_init(&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) + xc.backend_domname =3D C.CString(x.BackendDomname) + return xc, 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 +1406,25 @@ 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) { + C.libxl_device_usbdev_init(&xc) + xc.ctrl =3D C.libxl_devid(x.Ctrl) + xc.port =3D C.int(x.Port) + return xc, 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) { + C.libxl_device_dtdev_init(&xc) + xc.path =3D C.CString(x.Path) + return xc, 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 +1436,19 @@ 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) { + C.libxl_device_vtpm_init(&xc) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + xc.backend_domname =3D C.CString(x.BackendDomname) + xc.devid =3D C.libxl_devid(x.Devid) + xc.uuid, err =3D x.Uuid.toC() + if err !=3D nil { + C.libxl_device_vtpm_dispose(&xc) + return xc, err + } + return xc, nil +} + func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -840,6 +1460,17 @@ func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error= { return nil } =20 +func (x *DeviceP9) toC() (xc C.libxl_device_p9, err error) { + C.libxl_device_p9_init(&xc) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + xc.backend_domname =3D C.CString(x.BackendDomname) + xc.tag =3D C.CString(x.Tag) + xc.path =3D C.CString(x.Path) + xc.security_model =3D C.CString(x.SecurityModel) + xc.devid =3D C.libxl_devid(x.Devid) + return xc, 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 +1479,14 @@ 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) { + C.libxl_device_pvcallsif_init(&xc) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + xc.backend_domname =3D C.CString(x.BackendDomname) + xc.devid =3D C.libxl_devid(x.Devid) + return xc, 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 +1517,15 @@ func (x *DeviceChannelConnectionUnionSocket) fromC(xc= *C.libxl_device_channel) e return nil } =20 +func (x *DeviceChannel) toC() (xc C.libxl_device_channel, err error) { + C.libxl_device_channel_init(&xc) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + xc.backend_domname =3D C.CString(x.BackendDomname) + xc.devid =3D C.libxl_devid(x.Devid) + xc.name =3D C.CString(x.Name) + return xc, 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 +1534,14 @@ func (x *ConnectorParam) fromC(xc *C.libxl_connector_= param) error { return nil } =20 +func (x *ConnectorParam) toC() (xc C.libxl_connector_param, err error) { + C.libxl_connector_param_init(&xc) + 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 xc, 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 +1559,15 @@ 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) { + C.libxl_device_vdispl_init(&xc) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + 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 xc, 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 +1588,14 @@ 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) { + C.libxl_vsnd_params_init(&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 xc, 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 +1606,18 @@ 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) { + C.libxl_vsnd_stream_init(&xc) + xc.unique_id =3D C.CString(x.UniqueId) + xc._type =3D C.libxl_vsnd_stream_type(x.Type) + xc.params, err =3D x.Params.toC() + if err !=3D nil { + C.libxl_vsnd_stream_dispose(&xc) + return xc, err + } + return xc, nil +} + func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error { x.Name =3D C.GoString(xc.name) if err :=3D x.Params.fromC(&xc.params); err !=3D nil { @@ -950,6 +1635,17 @@ func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error { return nil } =20 +func (x *VsndPcm) toC() (xc C.libxl_vsnd_pcm, err error) { + C.libxl_vsnd_pcm_init(&xc) + xc.name =3D C.CString(x.Name) + xc.params, err =3D x.Params.toC() + if err !=3D nil { + C.libxl_vsnd_pcm_dispose(&xc) + return xc, err + } + return xc, nil +} + func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error { x.BackendDomid =3D Domid(xc.backend_domid) x.BackendDomname =3D C.GoString(xc.backend_domname) @@ -971,6 +1667,21 @@ 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) { + C.libxl_device_vsnd_init(&xc) + xc.backend_domid =3D C.libxl_domid(x.BackendDomid) + xc.backend_domname =3D C.CString(x.BackendDomname) + xc.devid =3D C.libxl_devid(x.Devid) + xc.short_name =3D C.CString(x.ShortName) + xc.long_name =3D C.CString(x.LongName) + xc.params, err =3D x.Params.toC() + if err !=3D nil { + C.libxl_device_vsnd_dispose(&xc) + return xc, err + } + return xc, nil +} + func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error { if err :=3D x.CInfo.fromC(&xc.c_info); err !=3D nil { return err @@ -1107,6 +1818,26 @@ 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) { + C.libxl_domain_config_init(&xc) + xc.c_info, err =3D x.CInfo.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + xc.b_info, err =3D x.BInfo.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, 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 xc, 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 +1851,19 @@ func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error= { return nil } =20 +func (x *Diskinfo) toC() (xc C.libxl_diskinfo, err error) { + C.libxl_diskinfo_init(&xc) + xc.backend =3D C.CString(x.Backend) + xc.backend_id =3D C.uint32_t(x.BackendId) + 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 xc, 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 +1878,20 @@ func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error { return nil } =20 +func (x *Nicinfo) toC() (xc C.libxl_nicinfo, err error) { + C.libxl_nicinfo_init(&xc) + xc.backend =3D C.CString(x.Backend) + xc.backend_id =3D C.uint32_t(x.BackendId) + 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 xc, 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 +1908,24 @@ func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error= { return nil } =20 +func (x *Vtpminfo) toC() (xc C.libxl_vtpminfo, err error) { + C.libxl_vtpminfo_init(&xc) + xc.backend =3D C.CString(x.Backend) + xc.backend_id =3D C.uint32_t(x.BackendId) + 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) + xc.uuid, err =3D x.Uuid.toC() + if err !=3D nil { + C.libxl_vtpminfo_dispose(&xc) + return xc, err + } + return xc, nil +} + func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo) error { x.Type =3D UsbctrlType(xc._type) x.Devid =3D Devid(xc.devid) @@ -1167,6 +1943,23 @@ func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo)= error { return nil } =20 +func (x *Usbctrlinfo) toC() (xc C.libxl_usbctrlinfo, err error) { + C.libxl_usbctrlinfo_init(&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 =3D C.CString(x.Backend) + xc.backend_id =3D C.uint32_t(x.BackendId) + 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 xc, nil +} + func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error { x.Vcpuid =3D uint32(xc.vcpuid) x.Cpu =3D uint32(xc.cpu) @@ -1184,6 +1977,27 @@ func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error= { return nil } =20 +func (x *Vcpuinfo) toC() (xc C.libxl_vcpuinfo, err error) { + C.libxl_vcpuinfo_init(&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) + xc.cpumap, err =3D x.Cpumap.toC() + if err !=3D nil { + C.libxl_vcpuinfo_dispose(&xc) + return xc, err + } + xc.cpumap_soft, err =3D x.CpumapSoft.toC() + if err !=3D nil { + C.libxl_vcpuinfo_dispose(&xc) + return xc, err + } + return xc, 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 +2025,35 @@ func (x *Physinfo) fromC(xc *C.libxl_physinfo) error= { return nil } =20 +func (x *Physinfo) toC() (xc C.libxl_physinfo, err error) { + C.libxl_physinfo_init(&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) + xc.hw_cap, err =3D x.HwCap.toC() + if err !=3D nil { + C.libxl_physinfo_dispose(&xc) + return xc, 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 xc, 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 +2066,18 @@ func (x *Connectorinfo) fromC(xc *C.libxl_connectori= nfo) error { return nil } =20 +func (x *Connectorinfo) toC() (xc C.libxl_connectorinfo, err error) { + C.libxl_connectorinfo_init(&xc) + 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 xc, 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 +2098,18 @@ func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) e= rror { return nil } =20 +func (x *Vdisplinfo) toC() (xc C.libxl_vdisplinfo, err error) { + C.libxl_vdisplinfo_init(&xc) + xc.backend =3D C.CString(x.Backend) + xc.backend_id =3D C.uint32_t(x.BackendId) + 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 xc, 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 +2117,13 @@ func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) e= rror { return nil } =20 +func (x *Streaminfo) toC() (xc C.libxl_streaminfo, err error) { + C.libxl_streaminfo_init(&xc) + xc.req_evtch =3D C.int(x.ReqEvtch) + xc.req_rref =3D C.int(x.ReqRref) + return xc, 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 +2137,11 @@ func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error { return nil } =20 +func (x *Pcminfo) toC() (xc C.libxl_pcminfo, err error) { + C.libxl_pcminfo_init(&xc) + return xc, nil +} + func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -1282,6 +2161,17 @@ func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error= { return nil } =20 +func (x *Vsndinfo) toC() (xc C.libxl_vsndinfo, err error) { + C.libxl_vsndinfo_init(&xc) + xc.backend =3D C.CString(x.Backend) + xc.backend_id =3D C.uint32_t(x.BackendId) + 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 xc, 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 +2185,19 @@ func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error { return nil } =20 +func (x *Vkbinfo) toC() (xc C.libxl_vkbinfo, err error) { + C.libxl_vkbinfo_init(&xc) + xc.backend =3D C.CString(x.Backend) + xc.backend_id =3D C.uint32_t(x.BackendId) + 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 xc, nil +} + func (x *Numainfo) fromC(xc *C.libxl_numainfo) error { x.Size =3D uint64(xc.size) x.Free =3D uint64(xc.free) @@ -1308,6 +2211,13 @@ func (x *Numainfo) fromC(xc *C.libxl_numainfo) error= { return nil } =20 +func (x *Numainfo) toC() (xc C.libxl_numainfo, err error) { + C.libxl_numainfo_init(&xc) + xc.size =3D C.uint64_t(x.Size) + xc.free =3D C.uint64_t(x.Free) + return xc, nil +} + func (x *Cputopology) fromC(xc *C.libxl_cputopology) error { x.Core =3D uint32(xc.core) x.Socket =3D uint32(xc.socket) @@ -1316,6 +2226,14 @@ func (x *Cputopology) fromC(xc *C.libxl_cputopology)= error { return nil } =20 +func (x *Cputopology) toC() (xc C.libxl_cputopology, err error) { + C.libxl_cputopology_init(&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 xc, nil +} + func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error { x.Seg =3D uint16(xc.seg) x.Bus =3D byte(xc.bus) @@ -1325,6 +2243,15 @@ func (x *Pcitopology) fromC(xc *C.libxl_pcitopology)= error { return nil } =20 +func (x *Pcitopology) toC() (xc C.libxl_pcitopology, err error) { + C.libxl_pcitopology_init(&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 xc, 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 +2260,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 err= or) { + C.libxl_sched_credit_params_init(&xc) + 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 xc, 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 e= rror) { + C.libxl_sched_credit2_params_init(&xc) + xc.ratelimit_us =3D C.int(x.RatelimitUs) + return xc, 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 +2308,48 @@ 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) { + C.libxl_domain_remus_info_init(&xc) + xc.interval =3D C.int(x.Interval) + xc.allow_unsafe, err =3D x.AllowUnsafe.toC() + if err !=3D nil { + C.libxl_domain_remus_info_dispose(&xc) + return xc, err + } + xc.blackhole, err =3D x.Blackhole.toC() + if err !=3D nil { + C.libxl_domain_remus_info_dispose(&xc) + return xc, err + } + xc.compression, err =3D x.Compression.toC() + if err !=3D nil { + C.libxl_domain_remus_info_dispose(&xc) + return xc, err + } + xc.netbuf, err =3D x.Netbuf.toC() + if err !=3D nil { + C.libxl_domain_remus_info_dispose(&xc) + return xc, err + } + xc.netbufscript =3D C.CString(x.Netbufscript) + xc.diskbuf, err =3D x.Diskbuf.toC() + if err !=3D nil { + C.libxl_domain_remus_info_dispose(&xc) + return xc, err + } + xc.colo, err =3D x.Colo.toC() + if err !=3D nil { + C.libxl_domain_remus_info_dispose(&xc) + return xc, err + } + xc.userspace_colo_proxy, err =3D x.UserspaceColoProxy.toC() + if err !=3D nil { + C.libxl_domain_remus_info_dispose(&xc) + return xc, err + } + return xc, nil +} + func (x *Event) fromC(xc *C.libxl_event) error { if err :=3D x.Link.fromC(&xc.link); err !=3D nil { return err @@ -1436,6 +2419,23 @@ func (x *EventTypeUnionOperationComplete) fromC(xc *= C.libxl_event) error { return nil } =20 +func (x *Event) toC() (xc C.libxl_event, err error) { + C.libxl_event_init(&xc) + xc.link, err =3D x.Link.toC() + if err !=3D nil { + C.libxl_event_dispose(&xc) + return xc, err + } + xc.domid =3D C.libxl_domid(x.Domid) + xc.domuuid, err =3D x.Domuuid.toC() + if err !=3D nil { + C.libxl_event_dispose(&xc) + return xc, err + } + xc.for_user =3D C.uint64_t(x.ForUser) + return xc, 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 +2445,15 @@ 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) { + C.libxl_psr_cat_info_init(&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 xc, 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 +2500,9 @@ func (x *PsrHwInfoTypeUnionMba) fromC(xc *C.libxl_psr= _hw_info) error { x.Linear =3D bool(tmp.linear) return nil } + +func (x *PsrHwInfo) toC() (xc C.libxl_psr_hw_info, err error) { + C.libxl_psr_hw_info_init(&xc) + xc.id =3D C.uint32_t(x.Id) + return xc, nil +} --=20 2.17.1 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel From nobody Tue May 7 14:51:30 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=1577114347; cv=none; d=zohomail.com; s=zohoarc; b=X3Pnhrlk1TNbqF+2ZfA08wIAUKYrkadAdeywhZ0RVwoHWcyDPFR6IJZqopFpKbUGRwiqwjubU7sbxU7qweXLHpiD0jiqUpTtvHxcQtaPv9WHVshiCL0tIw7xFMei9DybtZzXwBWfAgo01z+elS0GEIhBWUthMSw9nQdklx9fiUg= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1577114347; 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=TuTlrk4/ldiBHs/i5DAKL8ui2T/snxtOpsgbtcLX4AI=; b=OzxHGN86YwK7RZ2kxosy+duUG7bpKJsT+f4Nih17GXfZp2x1iJ9AydwsTkx0b2TzEW1XjnyKkR/Qrwu6qVbudDF4bjBCQHit4EvReNVldsVxpopTV3+NyfUeDq+IFBWMnbgwczQvmHYgGJhVSlIiqLgxMOAjlUYGm13lDRmwXqA= 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 1577114347671950.126030568091; Mon, 23 Dec 2019 07:19:07 -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 1ijPT8-0006LW-Q6; Mon, 23 Dec 2019 15:18:02 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1ijPT7-0006L9-H9 for xen-devel@lists.xenproject.org; Mon, 23 Dec 2019 15:18:01 +0000 Received: from mail-qk1-x735.google.com (unknown [2607:f8b0:4864:20::735]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 61fc91f8-2597-11ea-88e7-bc764e2007e4; Mon, 23 Dec 2019 15:17:50 +0000 (UTC) Received: by mail-qk1-x735.google.com with SMTP id j9so14147210qkk.1 for ; Mon, 23 Dec 2019 07:17:50 -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 u15sm5823907qku.67.2019.12.23.07.17.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 23 Dec 2019 07:17:48 -0800 (PST) X-Inumbo-ID: 61fc91f8-2597-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=7RvqR+8RmCVrc5ss1vsqFIrpOywrRiZJTYQb8T+T+c0=; b=kzH123YkoHsccstYOcr2Dgk0pz7WpDIc+Up2PGBKnMVFwrgPHB0GY9cCnBSMQXZcSi wZ8TugaOc2zYbeG4bZ2APSnpw2IUe8jqJHI/x2QIbToMDOZ+8WI/aQ0U47Taq+HZte0B 8EcUqO/lSYBQEQkzor4PZkea0pyZfTagOxmau1i+8WFt+IW8cF8/ddEV3OeOucMnNXBt G82SxSniubkFo8Vh3a5nFNwgaCKoSOyMYGzq0T53C5tepeneacTGtVPP4/vcDBIj2OLw Xm4LR6nMchEfi+pnqiLiYXUYqrmNe9Upe679bhIm91M/77GdjbtFawZ1VsCfuzNikgKd 95ew== 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=7RvqR+8RmCVrc5ss1vsqFIrpOywrRiZJTYQb8T+T+c0=; b=bYvprpCjRJl42H5ZpUSlOfksB7o60RB7yRbD8N/fLJtG9dReL03cuYd35QQkGSkgZd IPDMvFISSiijx9zFlXruMIuDyzh9kr4ljwSRNG9lyHvAA7DnH6eGzpf+LntbzEXlne3+ yosLO4l4ttIKLEcEcOAeGV4FqGnK5xl2rjrgozyAi0nTXgOPHPoAO3XBRo8KNqzESqUD 1VVM/DJyiNXtx9Sg3xx9hUNYOUq9Wwwj7G8eg+N03dMXzVKwU/sI7PKivb7LcEz6tYcv XayBMd78+Qck3b4Kfh9V1uWnkoGn629OqxWWtmeNVVXU5E9krb/qDx2RiTgiBIrcHUiS 4aRA== X-Gm-Message-State: APjAAAWdNB6osNskwRkC9VKTpIx0L6JbsQrVzfRDTpFW4S0IPJTfT/Wv bz72LwfNX53f9KtFbWPaOGYdwURx X-Google-Smtp-Source: APXvYqyLu++Cb4wasE9eesQsafB6ZSV7hg+a8xQTFsbyRH/GzxT7GLI0qUL0wUvoAA8H/lQ5co4MCw== X-Received: by 2002:a37:9fc9:: with SMTP id i192mr25652605qke.364.1577114269449; Mon, 23 Dec 2019 07:17:49 -0800 (PST) From: Nick Rosbrook X-Google-Original-From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Mon, 23 Dec 2019 10:17:04 -0500 Message-Id: <76a6287109680626e816c9f2d8f0a7666fef8ee9.1577111872.git.rosbrookn@ainfosec.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Subject: [Xen-devel] [PATCH v4 3/6] 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 , kerriganb@ainfosec.com, 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 --- tools/golang/xenlight/gengotypes.py | 77 ++++++- tools/golang/xenlight/helpers.gen.go | 325 +++++++++++++++++++++++++++ 2 files changed, 400 insertions(+), 2 deletions(-) diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/ge= ngotypes.py index 9d5f8300a2..b377fd9a25 100644 --- a/tools/golang/xenlight/gengotypes.py +++ b/tools/golang/xenlight/gengotypes.py @@ -502,8 +502,7 @@ def xenlight_golang_define_to_C(ty =3D None, typename = =3D None, nested =3D False): s +=3D xenlight_golang_define_to_C(f.type, typename=3Df.name, = nested=3DTrue) =20 elif isinstance(f.type, idl.KeyedUnion): - # TODO - pass + s +=3D xenlight_golang_union_to_C(f.type, f.name, ty.typename,= ty.dispose_fn) =20 else: raise Exception('type {} not supported'.format(f.type)) @@ -514,6 +513,80 @@ def xenlight_golang_define_to_C(ty =3D None, typename = =3D None, nested =3D False): =20 return s =20 +def xenlight_golang_union_to_C(ty =3D None, union_name =3D '', + struct_name =3D '', dispose_fn =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) + goname =3D '{}_{}'.format(keyname,f.name) + goname =3D xenlight_golang_fmt_name(goname,exported=3DFalse) + + 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 'C.{}(&xc)\n'.format(dispose_fn) + s +=3D 'return xc,errors.New("wrong type for union key {}")\n'.for= mat(keyname) + s +=3D '}\n' + + s +=3D 'var {} C.{}\n'.format(f.name,cgotype) + for uf in f.type.fields: + gotypename =3D xenlight_golang_fmt_name(uf.type.typename) + ctypename =3D uf.type.typename + gofname =3D xenlight_golang_fmt_name(uf.name) + + is_castable =3D (uf.type.json_parse_type =3D=3D 'JSON_INTEGER'= or + isinstance(uf.type, idl.Enumeration) or + gotypename in go_builtin_types) + + if not is_castable: + s +=3D '{}.{}, err =3D tmp.{}.toC()\n'.format(f.name,uf.na= me,gofname) + s +=3D 'if err !=3D nil {\n' + s +=3D 'C.{}(&xc)\n'.format(dispose_fn) + s +=3D 'return xc,err \n}\n' + + elif gotypename =3D=3D 'string': + s +=3D '{}.{} =3D C.CString(tmp.{})\n'.format(f.name,uf.na= me,gofname) + + else: + s +=3D '{}.{} =3D C.{}(tmp.{})\n'.format(f.name,uf.name,ct= ypename,gofname) + + # 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 xc, fmt.Errorf({})'.format(err_string) + s +=3D '}\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 be80d6c718..15548f9d6e 100644 --- a/tools/golang/xenlight/helpers.gen.go +++ b/tools/golang/xenlight/helpers.gen.go @@ -326,6 +326,21 @@ func (x *Channelinfo) toC() (xc C.libxl_channelinfo, e= rr 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 { + C.libxl_channelinfo_dispose(&xc) + return xc, errors.New("wrong type for union key connection") + } + var pty C.libxl_channelinfo_connection_union_pty + pty.path =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 xc, fmt.Errorf("invalid union key '%v'", x.Connection) + } return xc, nil } =20 @@ -1019,6 +1034,216 @@ func (x *DomainBuildInfo) toC() (xc C.libxl_domain_= build_info, err error) { return xc, 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 { + C.libxl_domain_build_info_dispose(&xc) + return xc, errors.New("wrong type for union key type") + } + var hvm C.libxl_domain_build_info_type_union_hvm + hvm.firmware =3D C.CString(tmp.Firmware) + hvm.bios =3D C.libxl_bios_type(tmp.Bios) + hvm.pae, err =3D tmp.Pae.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.apic, err =3D tmp.Apic.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.acpi, err =3D tmp.Acpi.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.acpi_s3, err =3D tmp.AcpiS3.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.acpi_s4, err =3D tmp.AcpiS4.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.acpi_laptop_slate, err =3D tmp.AcpiLaptopSlate.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.nx, err =3D tmp.Nx.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.viridian, err =3D tmp.Viridian.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.viridian_enable, err =3D tmp.ViridianEnable.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.viridian_disable, err =3D tmp.ViridianDisable.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.timeoffset =3D C.CString(tmp.Timeoffset) + hvm.hpet, err =3D tmp.Hpet.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.vpt_align, err =3D tmp.VptAlign.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.mmio_hole_memkb =3D C.uint64_t(tmp.MmioHoleMemkb) + hvm.timer_mode =3D C.libxl_timer_mode(tmp.TimerMode) + hvm.nested_hvm, err =3D tmp.NestedHvm.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.altp2m, err =3D tmp.Altp2M.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.system_firmware =3D C.CString(tmp.SystemFirmware) + hvm.smbios_firmware =3D C.CString(tmp.SmbiosFirmware) + hvm.acpi_firmware =3D C.CString(tmp.AcpiFirmware) + hvm.hdtype =3D C.libxl_hdtype(tmp.Hdtype) + hvm.nographic, err =3D tmp.Nographic.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.vga, err =3D tmp.Vga.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.vnc, err =3D tmp.Vnc.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.keymap =3D C.CString(tmp.Keymap) + hvm.sdl, err =3D tmp.Sdl.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.spice, err =3D tmp.Spice.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.gfx_passthru, err =3D tmp.GfxPassthru.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.gfx_passthru_kind =3D C.libxl_gfx_passthru_kind(tmp.GfxPassthruKind) + hvm.serial =3D C.CString(tmp.Serial) + hvm.boot =3D C.CString(tmp.Boot) + hvm.usb, err =3D tmp.Usb.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.usbversion =3D C.int(tmp.Usbversion) + hvm.usbdevice =3D C.CString(tmp.Usbdevice) + hvm.vkb_device, err =3D tmp.VkbDevice.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.soundhw =3D C.CString(tmp.Soundhw) + hvm.xen_platform_pci, err =3D tmp.XenPlatformPci.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.usbdevice_list, err =3D tmp.UsbdeviceList.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.vendor_device =3D C.libxl_vendor_device(tmp.VendorDevice) + hvm.ms_vm_genid, err =3D tmp.MsVmGenid.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.serial_list, err =3D tmp.SerialList.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + hvm.rdm, err =3D tmp.Rdm.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, 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 { + C.libxl_domain_build_info_dispose(&xc) + return xc, errors.New("wrong type for union key type") + } + var pv C.libxl_domain_build_info_type_union_pv + pv.kernel =3D C.CString(tmp.Kernel) + pv.slack_memkb =3D C.uint64_t(tmp.SlackMemkb) + pv.bootloader =3D C.CString(tmp.Bootloader) + pv.bootloader_args, err =3D tmp.BootloaderArgs.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + pv.cmdline =3D C.CString(tmp.Cmdline) + pv.ramdisk =3D C.CString(tmp.Ramdisk) + pv.features =3D C.CString(tmp.Features) + pv.e820_host, err =3D tmp.E820Host.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, 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 { + C.libxl_domain_build_info_dispose(&xc) + return xc, errors.New("wrong type for union key type") + } + var pvh C.libxl_domain_build_info_type_union_pvh + pvh.pvshim, err =3D tmp.Pvshim.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + pvh.pvshim_path =3D C.CString(tmp.PvshimPath) + pvh.pvshim_cmdline =3D C.CString(tmp.PvshimCmdline) + 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 xc, 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) @@ -1410,6 +1635,22 @@ func (x *DeviceUsbdev) toC() (xc C.libxl_device_usbd= ev, err error) { C.libxl_device_usbdev_init(&xc) 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 { + C.libxl_device_usbdev_dispose(&xc) + return xc, errors.New("wrong type for union key type") + } + var hostdev C.libxl_device_usbdev_type_union_hostdev + hostdev.hostbus =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 xc, fmt.Errorf("invalid union key '%v'", x.Type) + } return xc, nil } =20 @@ -1523,6 +1764,21 @@ func (x *DeviceChannel) toC() (xc C.libxl_device_cha= nnel, err error) { xc.backend_domname =3D C.CString(x.BackendDomname) xc.devid =3D C.libxl_devid(x.Devid) 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 { + C.libxl_device_channel_dispose(&xc) + return xc, errors.New("wrong type for union key connection") + } + var socket C.libxl_device_channel_connection_union_socket + socket.path =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 xc, fmt.Errorf("invalid union key '%v'", x.Connection) + } return xc, nil } =20 @@ -2433,6 +2689,46 @@ func (x *Event) toC() (xc C.libxl_event, err error) { return xc, 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 { + C.libxl_event_dispose(&xc) + return xc, errors.New("wrong type for union key type") + } + var domain_shutdown C.libxl_event_type_union_domain_shutdown + domain_shutdown.shutdown_reason =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 { + C.libxl_event_dispose(&xc) + return xc, errors.New("wrong type for union key type") + } + var disk_eject C.libxl_event_type_union_disk_eject + disk_eject.vdev =3D C.CString(tmp.Vdev) + disk_eject.disk, err =3D tmp.Disk.toC() + if err !=3D nil { + C.libxl_event_dispose(&xc) + return xc, 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 { + C.libxl_event_dispose(&xc) + return xc, errors.New("wrong type for union key type") + } + var operation_complete C.libxl_event_type_union_operation_complete + operation_complete.rc =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 xc, fmt.Errorf("invalid union key '%v'", x.Type) + } return xc, nil } =20 @@ -2504,5 +2800,34 @@ func (x *PsrHwInfoTypeUnionMba) fromC(xc *C.libxl_ps= r_hw_info) error { func (x *PsrHwInfo) toC() (xc C.libxl_psr_hw_info, err error) { C.libxl_psr_hw_info_init(&xc) 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 { + C.libxl_psr_hw_info_dispose(&xc) + return xc, errors.New("wrong type for union key type") + } + var cat C.libxl_psr_hw_info_type_union_cat + cat.cos_max =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 { + C.libxl_psr_hw_info_dispose(&xc) + return xc, errors.New("wrong type for union key type") + } + var mba C.libxl_psr_hw_info_type_union_mba + mba.cos_max =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 xc, fmt.Errorf("invalid union key '%v'", x.Type) + } return xc, nil } --=20 2.17.1 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel From nobody Tue May 7 14:51:30 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=1577114345; cv=none; d=zohomail.com; s=zohoarc; b=X9Io63Ti+noViGFh3nQGlzVzcICGKnANL2VSUGdki7EH4ulQFh8c3OX0cZIjwGRJBrlMQny8YG/MJZ7XaasRQ8AE+NuxpLk2/ADNCPLZ8nmgV/8V+aeGuCCWE1j4Ad/7FgyI+BNTy2tZ27qp/CotasbXlrdUGGutnJZtNBjikqw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1577114345; 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=8Jslq5/MDd7hVH+imfOIYwrjfdzuEQThvOcsF+5CvvM=; b=OkliLIVUoUpsEU8h8HL+el17Kn8yAMSJqCipPriwIE7LbL7mkyOpH6ti4ZmbEMcIoSEcPqd5DT1nJ+dvfaWaDyV0ghJDlIvfyIEivXbX0JlmVQwwTqntXvMSK59DdQ6rfCBDJs561syKYrElM5EsuRqcWDP58moWjBPoe2KqYLU= 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 1577114345685932.7559725720272; Mon, 23 Dec 2019 07:19:05 -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 1ijPTE-0006Mt-3e; Mon, 23 Dec 2019 15:18:08 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1ijPTC-0006MU-Hm for xen-devel@lists.xenproject.org; Mon, 23 Dec 2019 15:18:06 +0000 Received: from mail-qk1-x744.google.com (unknown [2607:f8b0:4864:20::744]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 62f4c4fe-2597-11ea-88e7-bc764e2007e4; Mon, 23 Dec 2019 15:17:51 +0000 (UTC) Received: by mail-qk1-x744.google.com with SMTP id x129so13753360qke.8 for ; Mon, 23 Dec 2019 07:17:51 -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 u15sm5823907qku.67.2019.12.23.07.17.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 23 Dec 2019 07:17:50 -0800 (PST) X-Inumbo-ID: 62f4c4fe-2597-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=qIWGvbOapJP2AMLuU/QSd6YoV6wyKIPa2DBivfqk0oM=; b=IumXkIqV/+z4N/B3UxV00k4EkHHJG/8wzAL8aImJ5z23H/QJkA7+gnV54RcPqGtmkT jjrsVGYwKqDb6IHLXr8Di4bbX+OeeeCibbrqfRnu8x0ulkyffgi+VDm3yyWAMJEwW7qp 2XXOV9dVvFsBuQ3VfEbQzX4RhXX9YBpan6Wux9Hnr9od5BoLV+Ol4t+mKKisG7T6G0k+ aIuSdDKDS0ALkJ9ZpI9cdb6Arm/n7Sdq4I9HSNmsxqQPe0s5KGkajYSvotgBLmbxI6gl 2Gx/wuqJ3Lejwijz+j8Ku7CJpOqomZqsEEW8T1a3FbITMaxdurE7vsnA9qI8/R3b3PK0 zpww== 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=qIWGvbOapJP2AMLuU/QSd6YoV6wyKIPa2DBivfqk0oM=; b=bM5+/KOF1SEUeB5Oyzbq82gX8qq+5frNgMGHtNnzITzeqBbNAs50HClI8hQIOQ20P+ Eaph52ZFJlv4Xj5y7ULizrMYo4BVRxiTjQukrSlvCbH5un93kVc7tawBYowJizkIg+6B sXRZitvir/SXrOU9L8JBYxVlQ9Ycp+3EYE93sCPw5mh9gol4xTZgr9/i/v9je02gqSwc stG/VLlo9l/ehT15N+vgktWIaoG+hOkfvPWDefqLWwIJfLADvlIK7I45N6032NHeeabR +WDgQawRy6nvu53jcNZRu+x3axSQnRCANOeyIKBWZ2FEAHRfAi2eib0OYo49Nbcg53ag 4QIA== X-Gm-Message-State: APjAAAXXzU4P5gKB4c9ZleMoK1WTrx7xRCyyNxwKApPpfx7tqXz7ruSE W8bds8gKdxnpPsBIuP+YQ0wmVJn9 X-Google-Smtp-Source: APXvYqwmHOR8L9pUzbHCp0x+MPveQPT75YHeS7KxiuIKxuOmnzjZiRSxWdRXrYxNvsOtRsdP1nIfQw== X-Received: by 2002:a05:620a:b19:: with SMTP id t25mr27133610qkg.82.1577114270958; Mon, 23 Dec 2019 07:17:50 -0800 (PST) From: Nick Rosbrook X-Google-Original-From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Mon, 23 Dec 2019 10:17:05 -0500 Message-Id: <88056982bc116611da601b2d1249bb4be4bc07e9.1577111872.git.rosbrookn@ainfosec.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Subject: [Xen-devel] [PATCH v4 4/6] 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 , kerriganb@ainfosec.com, 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 --- tools/golang/xenlight/gengotypes.py | 44 +++- tools/golang/xenlight/helpers.gen.go | 359 +++++++++++++++++++++++++++ 2 files changed, 402 insertions(+), 1 deletion(-) diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/ge= ngotypes.py index b377fd9a25..a972754d36 100644 --- a/tools/golang/xenlight/gengotypes.py +++ b/tools/golang/xenlight/gengotypes.py @@ -456,7 +456,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 + s +=3D xenlight_golang_array_to_C(f, ty.dispose_fn) continue =20 gotypename =3D xenlight_golang_fmt_name(f.type.typename) @@ -587,6 +587,48 @@ 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, dispose_fn =3D ''): + 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 '{} :=3D len(x.{})\n'.format(golenvar,goname) + 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' + + return s + + s +=3D '{} :=3D len(x.{})\n'.format(golenvar,goname) + 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 'tmp, err :=3D v.toC()\n' + s +=3D 'if err !=3D nil {\n' + s +=3D 'C.{}(&xc)\n'.format(dispose_fn) + s +=3D 'return xc,err\n}\n' + s +=3D 'c{}[i] =3D tmp\n'.format(goname) + s +=3D '}\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 15548f9d6e..3e588dd1c2 100644 --- a/tools/golang/xenlight/helpers.gen.go +++ b/tools/golang/xenlight/helpers.gen.go @@ -543,6 +543,18 @@ func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched= _params) error { func (x *VcpuSchedParams) toC() (xc C.libxl_vcpu_sched_params, err error) { C.libxl_vcpu_sched_params_init(&xc) xc.sched =3D C.libxl_scheduler(x.Sched) + numVcpus :=3D len(x.Vcpus) + xc.vcpus =3D (*C.libxl_sched_params)(C.malloc(C.ulong(numVcpus) * C.sizeo= f_libxl_sched_params)) + xc.num_vcpus =3D C.int(numVcpus) + cVcpus :=3D (*[1 << 28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:n= umVcpus:numVcpus] + for i, v :=3D range x.Vcpus { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_vcpu_sched_params_dispose(&xc) + return xc, err + } + cVcpus[i] =3D tmp + } return xc, nil } =20 @@ -591,6 +603,13 @@ func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) erro= r { func (x *VnodeInfo) toC() (xc C.libxl_vnode_info, err error) { C.libxl_vnode_info_init(&xc) xc.memkb =3D C.uint64_t(x.Memkb) + numDistances :=3D len(x.Distances) + xc.distances =3D (*C.uint32_t)(C.malloc(C.size_t(numDistances * numDistan= ces))) + xc.num_distances =3D C.int(numDistances) + cDistances :=3D (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.distances))[:num= Distances:numDistances] + for i, v :=3D range x.Distances { + cDistances[i] =3D C.uint32_t(v) + } xc.pnode =3D C.uint32_t(x.Pnode) xc.vcpus, err =3D x.Vcpus.toC() if err !=3D nil { @@ -934,6 +953,30 @@ func (x *DomainBuildInfo) toC() (xc C.libxl_domain_bui= ld_info, err error) { C.libxl_domain_build_info_dispose(&xc) return xc, err } + numVcpuHardAffinity :=3D len(x.VcpuHardAffinity) + xc.vcpu_hard_affinity =3D (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuHardA= ffinity) * 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 { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + cVcpuHardAffinity[i] =3D tmp + } + numVcpuSoftAffinity :=3D len(x.VcpuSoftAffinity) + xc.vcpu_soft_affinity =3D (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuSoftA= ffinity) * 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 { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + cVcpuSoftAffinity[i] =3D tmp + } xc.numa_placement, err =3D x.NumaPlacement.toC() if err !=3D nil { C.libxl_domain_build_info_dispose(&xc) @@ -964,6 +1007,18 @@ func (x *DomainBuildInfo) toC() (xc C.libxl_domain_bu= ild_info, err error) { return xc, err } xc.blkdev_start =3D C.CString(x.BlkdevStart) + numVnumaNodes :=3D len(x.VnumaNodes) + 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_n= odes))[:numVnumaNodes:numVnumaNodes] + for i, v :=3D range x.VnumaNodes { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + cVnumaNodes[i] =3D tmp + } 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) @@ -996,6 +1051,37 @@ func (x *DomainBuildInfo) toC() (xc C.libxl_domain_bu= ild_info, err error) { C.libxl_domain_build_info_dispose(&xc) return xc, err } + numIoports :=3D len(x.Ioports) + xc.ioports =3D (*C.libxl_ioport_range)(C.malloc(C.ulong(numIoports) * C.s= izeof_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 { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + cIoports[i] =3D tmp + } + numIrqs :=3D len(x.Irqs) + 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:numIr= qs] + for i, v :=3D range x.Irqs { + cIrqs[i] =3D C.uint32_t(v) + } + numIomem :=3D len(x.Iomem) + xc.iomem =3D (*C.libxl_iomem_range)(C.malloc(C.ulong(numIomem) * C.sizeof= _libxl_iomem_range)) + xc.num_iomem =3D C.int(numIomem) + cIomem :=3D (*[1 << 28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:nu= mIomem:numIomem] + for i, v :=3D range x.Iomem { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_build_info_dispose(&xc) + return xc, err + } + cIomem[i] =3D tmp + } xc.claim_mode, err =3D x.ClaimMode.toC() if err !=3D nil { C.libxl_domain_build_info_dispose(&xc) @@ -1821,6 +1907,18 @@ func (x *DeviceVdispl) toC() (xc C.libxl_device_vdis= pl, err error) { xc.backend_domname =3D C.CString(x.BackendDomname) xc.devid =3D C.libxl_devid(x.Devid) xc.be_alloc =3D C.bool(x.BeAlloc) + numConnectors :=3D len(x.Connectors) + xc.connectors =3D (*C.libxl_connector_param)(C.malloc(C.ulong(numConnecto= rs) * C.sizeof_libxl_connector_param)) + xc.num_connectors =3D C.int(numConnectors) + cConnectors :=3D (*[1 << 28]C.libxl_connector_param)(unsafe.Pointer(xc.co= nnectors))[:numConnectors:numConnectors] + for i, v :=3D range x.Connectors { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_device_vdispl_dispose(&xc) + return xc, err + } + cConnectors[i] =3D tmp + } return xc, nil } =20 @@ -1846,6 +1944,20 @@ func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) = error { =20 func (x *VsndParams) toC() (xc C.libxl_vsnd_params, err error) { C.libxl_vsnd_params_init(&xc) + numSampleRates :=3D len(x.SampleRates) + xc.sample_rates =3D (*C.uint32_t)(C.malloc(C.size_t(numSampleRates * numS= ampleRates))) + 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) + } + numSampleFormats :=3D len(x.SampleFormats) + xc.sample_formats =3D (*C.libxl_vsnd_pcm_format)(C.malloc(C.size_t(numSam= pleFormats * numSampleFormats))) + xc.num_sample_formats =3D C.int(numSampleFormats) + cSampleFormats :=3D (*[1 << 28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc= .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) @@ -1899,6 +2011,18 @@ func (x *VsndPcm) toC() (xc C.libxl_vsnd_pcm, err er= ror) { C.libxl_vsnd_pcm_dispose(&xc) return xc, err } + numVsndStreams :=3D len(x.Streams) + 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 { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_vsnd_pcm_dispose(&xc) + return xc, err + } + cStreams[i] =3D tmp + } return xc, nil } =20 @@ -1935,6 +2059,18 @@ func (x *DeviceVsnd) toC() (xc C.libxl_device_vsnd, = err error) { C.libxl_device_vsnd_dispose(&xc) return xc, err } + numVsndPcms :=3D len(x.Pcms) + 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))[:numVsnd= Pcms:numVsndPcms] + for i, v :=3D range x.Pcms { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_device_vsnd_dispose(&xc) + return xc, err + } + cPcms[i] =3D tmp + } return xc, nil } =20 @@ -2086,6 +2222,186 @@ func (x *DomainConfig) toC() (xc C.libxl_domain_con= fig, err error) { C.libxl_domain_config_dispose(&xc) return xc, err } + numDisks :=3D len(x.Disks) + xc.disks =3D (*C.libxl_device_disk)(C.malloc(C.ulong(numDisks) * C.sizeof= _libxl_device_disk)) + xc.num_disks =3D C.int(numDisks) + cDisks :=3D (*[1 << 28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:nu= mDisks:numDisks] + for i, v :=3D range x.Disks { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cDisks[i] =3D tmp + } + numNics :=3D len(x.Nics) + xc.nics =3D (*C.libxl_device_nic)(C.malloc(C.ulong(numNics) * C.sizeof_li= bxl_device_nic)) + xc.num_nics =3D C.int(numNics) + cNics :=3D (*[1 << 28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:numNi= cs:numNics] + for i, v :=3D range x.Nics { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cNics[i] =3D tmp + } + numPcidevs :=3D len(x.Pcidevs) + xc.pcidevs =3D (*C.libxl_device_pci)(C.malloc(C.ulong(numPcidevs) * C.siz= eof_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 { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cPcidevs[i] =3D tmp + } + numRdms :=3D len(x.Rdms) + xc.rdms =3D (*C.libxl_device_rdm)(C.malloc(C.ulong(numRdms) * C.sizeof_li= bxl_device_rdm)) + xc.num_rdms =3D C.int(numRdms) + cRdms :=3D (*[1 << 28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:numRd= ms:numRdms] + for i, v :=3D range x.Rdms { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cRdms[i] =3D tmp + } + numDtdevs :=3D len(x.Dtdevs) + xc.dtdevs =3D (*C.libxl_device_dtdev)(C.malloc(C.ulong(numDtdevs) * C.siz= eof_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 { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cDtdevs[i] =3D tmp + } + numVfbs :=3D len(x.Vfbs) + xc.vfbs =3D (*C.libxl_device_vfb)(C.malloc(C.ulong(numVfbs) * C.sizeof_li= bxl_device_vfb)) + xc.num_vfbs =3D C.int(numVfbs) + cVfbs :=3D (*[1 << 28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:numVf= bs:numVfbs] + for i, v :=3D range x.Vfbs { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cVfbs[i] =3D tmp + } + numVkbs :=3D len(x.Vkbs) + xc.vkbs =3D (*C.libxl_device_vkb)(C.malloc(C.ulong(numVkbs) * C.sizeof_li= bxl_device_vkb)) + xc.num_vkbs =3D C.int(numVkbs) + cVkbs :=3D (*[1 << 28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:numVk= bs:numVkbs] + for i, v :=3D range x.Vkbs { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cVkbs[i] =3D tmp + } + numVtpms :=3D len(x.Vtpms) + xc.vtpms =3D (*C.libxl_device_vtpm)(C.malloc(C.ulong(numVtpms) * C.sizeof= _libxl_device_vtpm)) + xc.num_vtpms =3D C.int(numVtpms) + cVtpms :=3D (*[1 << 28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:nu= mVtpms:numVtpms] + for i, v :=3D range x.Vtpms { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cVtpms[i] =3D tmp + } + numP9S :=3D len(x.P9S) + xc.p9s =3D (*C.libxl_device_p9)(C.malloc(C.ulong(numP9S) * C.sizeof_libxl= _device_p9)) + xc.num_p9s =3D C.int(numP9S) + cP9S :=3D (*[1 << 28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:numP9S:n= umP9S] + for i, v :=3D range x.P9S { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cP9S[i] =3D tmp + } + numPvcallsifs :=3D len(x.Pvcallsifs) + xc.pvcallsifs =3D (*C.libxl_device_pvcallsif)(C.malloc(C.ulong(numPvcalls= ifs) * C.sizeof_libxl_device_pvcallsif)) + xc.num_pvcallsifs =3D C.int(numPvcallsifs) + cPvcallsifs :=3D (*[1 << 28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.p= vcallsifs))[:numPvcallsifs:numPvcallsifs] + for i, v :=3D range x.Pvcallsifs { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cPvcallsifs[i] =3D tmp + } + numVdispls :=3D len(x.Vdispls) + 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.vdispls= ))[:numVdispls:numVdispls] + for i, v :=3D range x.Vdispls { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cVdispls[i] =3D tmp + } + numVsnds :=3D len(x.Vsnds) + xc.vsnds =3D (*C.libxl_device_vsnd)(C.malloc(C.ulong(numVsnds) * C.sizeof= _libxl_device_vsnd)) + xc.num_vsnds =3D C.int(numVsnds) + cVsnds :=3D (*[1 << 28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:nu= mVsnds:numVsnds] + for i, v :=3D range x.Vsnds { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cVsnds[i] =3D tmp + } + numChannels :=3D len(x.Channels) + 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.chann= els))[:numChannels:numChannels] + for i, v :=3D range x.Channels { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cChannels[i] =3D tmp + } + numUsbctrls :=3D len(x.Usbctrls) + 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.usbct= rls))[:numUsbctrls:numUsbctrls] + for i, v :=3D range x.Usbctrls { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cUsbctrls[i] =3D tmp + } + numUsbdevs :=3D len(x.Usbdevs) + 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.usbdevs= ))[:numUsbdevs:numUsbdevs] + for i, v :=3D range x.Usbdevs { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_domain_config_dispose(&xc) + return xc, err + } + cUsbdevs[i] =3D tmp + } 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) @@ -2363,6 +2679,18 @@ func (x *Vdisplinfo) toC() (xc C.libxl_vdisplinfo, e= rr error) { xc.devid =3D C.libxl_devid(x.Devid) xc.state =3D C.int(x.State) xc.be_alloc =3D C.bool(x.BeAlloc) + numConnectors :=3D len(x.Connectors) + xc.connectors =3D (*C.libxl_connectorinfo)(C.malloc(C.ulong(numConnectors= ) * C.sizeof_libxl_connectorinfo)) + xc.num_connectors =3D C.int(numConnectors) + cConnectors :=3D (*[1 << 28]C.libxl_connectorinfo)(unsafe.Pointer(xc.conn= ectors))[:numConnectors:numConnectors] + for i, v :=3D range x.Connectors { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_vdisplinfo_dispose(&xc) + return xc, err + } + cConnectors[i] =3D tmp + } return xc, nil } =20 @@ -2395,6 +2723,18 @@ func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error { =20 func (x *Pcminfo) toC() (xc C.libxl_pcminfo, err error) { C.libxl_pcminfo_init(&xc) + numVsndStreams :=3D len(x.Streams) + 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 { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_pcminfo_dispose(&xc) + return xc, err + } + cStreams[i] =3D tmp + } return xc, nil } =20 @@ -2425,6 +2765,18 @@ func (x *Vsndinfo) toC() (xc C.libxl_vsndinfo, err e= rror) { xc.frontend_id =3D C.uint32_t(x.FrontendId) xc.devid =3D C.libxl_devid(x.Devid) xc.state =3D C.int(x.State) + numVsndPcms :=3D len(x.Pcms) + xc.pcms =3D (*C.libxl_pcminfo)(C.malloc(C.ulong(numVsndPcms) * C.sizeof_l= ibxl_pcminfo)) + xc.num_vsnd_pcms =3D C.int(numVsndPcms) + cPcms :=3D (*[1 << 28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:numVsndP= cms:numVsndPcms] + for i, v :=3D range x.Pcms { + tmp, err :=3D v.toC() + if err !=3D nil { + C.libxl_vsndinfo_dispose(&xc) + return xc, err + } + cPcms[i] =3D tmp + } return xc, nil } =20 @@ -2471,6 +2823,13 @@ func (x *Numainfo) toC() (xc C.libxl_numainfo, err e= rror) { C.libxl_numainfo_init(&xc) xc.size =3D C.uint64_t(x.Size) xc.free =3D C.uint64_t(x.Free) + numDists :=3D len(x.Dists) + 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:nu= mDists] + for i, v :=3D range x.Dists { + cDists[i] =3D C.uint32_t(v) + } return xc, nil } =20 --=20 2.17.1 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel From nobody Tue May 7 14:51:30 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=1577114345; cv=none; d=zohomail.com; s=zohoarc; b=Y9zDvwisqiQvISGBAigrPo3gwkFa2MCcAMUJe1Ze0W9hscMDOtBpQ5qOnfMbtW4FFof9HQ0KysweZjZ1lDPKpCXQxsnWs9uAc8j5yv0IcCrnxYSVTKlVlbAk+7oOsilJvTBYqEPxN8rrD+P5Y6XZ9+aNmm57LD/w9MJD17FXUUg= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1577114345; 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=pwVhU0muGEuZXiVpN7cw5RAIMQOBmU6YLalVze4U10Y=; b=M0/XtSEAiiFk/JfvI7V8a7qc60Tq2hADTxRgyqoEmYco80pjHJIALGpXRx2CYaPtPmXhSxMApsS9lbDeULcNeTkLCtcAULr7d7YDhkqlkQpe+saYPxdmm4XCCRIDkzwHuuiMESv/eXZ4+cFp+cPvD9usQ4qwPj5HYQ247B9upl4= 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 1577114345684977.1100279816654; Mon, 23 Dec 2019 07:19:05 -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 1ijPTI-0006PJ-IV; Mon, 23 Dec 2019 15:18:12 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1ijPTH-0006OM-HT for xen-devel@lists.xenproject.org; Mon, 23 Dec 2019 15:18:11 +0000 Received: from mail-qv1-xf43.google.com (unknown [2607:f8b0:4864:20::f43]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 63f59d1a-2597-11ea-88e7-bc764e2007e4; Mon, 23 Dec 2019 15:17:53 +0000 (UTC) Received: by mail-qv1-xf43.google.com with SMTP id y8so6461573qvk.6 for ; Mon, 23 Dec 2019 07:17:53 -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 u15sm5823907qku.67.2019.12.23.07.17.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 23 Dec 2019 07:17:52 -0800 (PST) X-Inumbo-ID: 63f59d1a-2597-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=2/djd1HHcfAAC+GQCcKQ0rXC67RaS5dl0perPfCjXCU=; b=bhBxfm239b2Ew6RK6pond/R4K2nr1KUbLKlaHFO+V3os4xGMzuDKBJIDQKYduzF4FG 4F/UIpy+2Nr4mQaBWwoOkzrkcBz/t154r7hizRh3FbyvY4N714GiPI497i3nxHBbIhKj xS6zcAotA6rMgZwEl8+vDsfQ65I8nMTER0FwvlfrgmEiB2YEAadjV6woRfrEyW63hijk axQrEjnbVOm4V4eR/Hg7+NqyDCm4QbS7UTXLzNQmyICA+K2+u9h7FfYkunCbwvMbm88E 24MHRV2bznmvzalW56d9KBtbew2HjrHRR0RXRVgaXJ5rKR4PjTAdnWTOoId4OJeT9NcU iSNg== 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=2/djd1HHcfAAC+GQCcKQ0rXC67RaS5dl0perPfCjXCU=; b=s/WOri2dPD1D86ajFdnyjO4IxTuTzaDhesXfA44lowLvwUCRHv386H7zp5m2WdPMKG HgLJMSHGQfs61udMtOXIeK4d/TTZvHW0av6CXR/kZ9K4mh3vE2HSQNvvXgjTnygVoUd4 ZlcmilDGBzGj5iZu9iyWPyvR+N/Hf246vVLmqS2MVOKuKQflcDer+3CREBoVIT1D1sMH oGkv+j70cNv8ev1Vxa4gwBhJRvOuw7tWNncLxZzk+PyLJDkQJRCt7pr3QHttLCiA4mJL SmcMHRqru1+5X57QFNS5ijY6jPYg0M94oV6UH+49+mH0ru7YoIqZkec1vMfR+cKCH88v /OXg== X-Gm-Message-State: APjAAAXxWz4ror1kq8hH2zlkCWJnYqfVCHX+hONeBgZylhD0HnYxxiYB XiuV4ofPpgRL6rra5IcSksXr8m1U X-Google-Smtp-Source: APXvYqxxFYJ/XCNh4xlWiIV1s4Gj9sz/OhFaaODBGt+6tw7/k9y/iQu6iuwkCnz7FnNFKK4CKNmlnA== X-Received: by 2002:ad4:4b6d:: with SMTP id m13mr25378784qvx.240.1577114272678; Mon, 23 Dec 2019 07:17:52 -0800 (PST) From: Nick Rosbrook X-Google-Original-From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Mon, 23 Dec 2019 10:17:06 -0500 Message-Id: <0eca74c58eb2e51cd87f48b8593a2c8065ad2996.1577111872.git.rosbrookn@ainfosec.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Subject: [Xen-devel] [PATCH v4 5/6] golang/xenlight: revise use of Context type X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Nick Rosbrook , Ian Jackson , kerriganb@ainfosec.com, George Dunlap , Wei Liu 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) Remove the exported global context variable, 'Ctx.' Generally, it is better to not export global variables for use through a Go package. However, there are some exceptions that can be found in the standard library. Add a NewContext function instead, and remove the Open, IsOpen, and CheckOpen functions as a result. Also, comment-out an ineffectual assignment to 'err' inside the function Context.CpupoolInfo so that compilation does not fail. Signed-off-by: Nick Rosbrook Reviewed-by: George Dunlap --- Changes in v4: - Add line break to excessively long line in NewContext. --- tools/golang/xenlight/xenlight.go | 220 +++++------------------------- 1 file changed, 35 insertions(+), 185 deletions(-) diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenl= ight.go index f32eb11384..5f14cab6ce 100644 --- a/tools/golang/xenlight/xenlight.go +++ b/tools/golang/xenlight/xenlight.go @@ -74,6 +74,40 @@ func (e Error) Error() string { return fmt.Sprintf("libxl error: %d", -e) } =20 +// Context represents a libxl_ctx. +type Context struct { + ctx *C.libxl_ctx + logger *C.xentoollog_logger_stdiostream +} + +// NewContext returns a new Context. +func NewContext() (*Context, error) { + var ctx Context + + ctx.logger =3D C.xtl_createlogger_stdiostream(C.stderr, C.XTL_ERROR, 0) + + ret :=3D C.libxl_ctx_alloc(&ctx.ctx, C.LIBXL_VERSION, 0, + (*C.xentoollog_logger)(unsafe.Pointer(ctx.logger))) + if ret !=3D 0 { + return nil, Error(ret) + } + + return &ctx, nil +} + +// Close closes the Context. +func (ctx *Context) Close() error { + ret :=3D C.libxl_ctx_free(ctx.ctx) + ctx.ctx =3D nil + C.xtl_logger_destroy((*C.xentoollog_logger)(unsafe.Pointer(ctx.logger))) + + if ret !=3D 0 { + return Error(ret) + } + + return nil +} + /* * Types: Builtins */ @@ -298,11 +332,6 @@ func (cpl CpuidPolicyList) toC() (C.libxl_cpuid_policy= _list, error) { return ccpl, nil } =20 -type Context struct { - ctx *C.libxl_ctx - logger *C.xentoollog_logger_stdiostream -} - // Hwcap represents a libxl_hwcap. type Hwcap [8]uint32 =20 @@ -453,11 +482,6 @@ func SchedulerFromString(name string) (s Scheduler, er= r error) { // libxl_cpupoolinfo * libxl_list_cpupool(libxl_ctx*, int *nb_pool_out); // void libxl_cpupoolinfo_list_free(libxl_cpupoolinfo *list, int nb_pool); func (Ctx *Context) ListCpupool() (list []Cpupoolinfo) { - err :=3D Ctx.CheckOpen() - if err !=3D nil { - return - } - var nbPool C.int =20 c_cpupool_list :=3D C.libxl_list_cpupool(Ctx.ctx, &nbPool) @@ -481,16 +505,11 @@ func (Ctx *Context) ListCpupool() (list []Cpupoolinfo= ) { =20 // int libxl_cpupool_info(libxl_ctx *ctx, libxl_cpupoolinfo *info, uint32_= t poolid); func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool Cpupoolinfo) { - err :=3D Ctx.CheckOpen() - if err !=3D nil { - return - } - var c_cpupool C.libxl_cpupoolinfo =20 ret :=3D C.libxl_cpupool_info(Ctx.ctx, &c_cpupool, C.uint32_t(Poolid)) if ret !=3D 0 { - err =3D Error(-ret) + //err =3D Error(-ret) return } defer C.libxl_cpupoolinfo_dispose(&c_cpupool) @@ -507,11 +526,6 @@ func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool C= pupoolinfo) { // FIXME: uuid // FIXME: Setting poolid func (Ctx *Context) CpupoolCreate(Name string, Scheduler Scheduler, Cpumap= Bitmap) (err error, Poolid uint32) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - poolid :=3D C.uint32_t(C.LIBXL_CPUPOOL_POOLID_ANY) name :=3D C.CString(Name) defer C.free(unsafe.Pointer(name)) @@ -540,11 +554,6 @@ func (Ctx *Context) CpupoolCreate(Name string, Schedul= er Scheduler, Cpumap Bitma =20 // int libxl_cpupool_destroy(libxl_ctx *ctx, uint32_t poolid); func (Ctx *Context) CpupoolDestroy(Poolid uint32) (err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ret :=3D C.libxl_cpupool_destroy(Ctx.ctx, C.uint32_t(Poolid)) if ret !=3D 0 { err =3D Error(-ret) @@ -556,11 +565,6 @@ func (Ctx *Context) CpupoolDestroy(Poolid uint32) (err= error) { =20 // int libxl_cpupool_cpuadd(libxl_ctx *ctx, uint32_t poolid, int cpu); func (Ctx *Context) CpupoolCpuadd(Poolid uint32, Cpu int) (err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ret :=3D C.libxl_cpupool_cpuadd(Ctx.ctx, C.uint32_t(Poolid), C.int(Cpu)) if ret !=3D 0 { err =3D Error(-ret) @@ -573,11 +577,6 @@ func (Ctx *Context) CpupoolCpuadd(Poolid uint32, Cpu i= nt) (err error) { // int libxl_cpupool_cpuadd_cpumap(libxl_ctx *ctx, uint32_t poolid, // const libxl_bitmap *cpumap); func (Ctx *Context) CpupoolCpuaddCpumap(Poolid uint32, Cpumap Bitmap) (err= error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - cbm, err :=3D Cpumap.toC() if err !=3D nil { return @@ -595,11 +594,6 @@ func (Ctx *Context) CpupoolCpuaddCpumap(Poolid uint32,= Cpumap Bitmap) (err error =20 // int libxl_cpupool_cpuremove(libxl_ctx *ctx, uint32_t poolid, int cpu); func (Ctx *Context) CpupoolCpuremove(Poolid uint32, Cpu int) (err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ret :=3D C.libxl_cpupool_cpuremove(Ctx.ctx, C.uint32_t(Poolid), C.int(Cpu= )) if ret !=3D 0 { err =3D Error(-ret) @@ -612,11 +606,6 @@ func (Ctx *Context) CpupoolCpuremove(Poolid uint32, Cp= u int) (err error) { // int libxl_cpupool_cpuremove_cpumap(libxl_ctx *ctx, uint32_t poolid, // const libxl_bitmap *cpumap); func (Ctx *Context) CpupoolCpuremoveCpumap(Poolid uint32, Cpumap Bitmap) (= err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - cbm, err :=3D Cpumap.toC() if err !=3D nil { return @@ -634,11 +623,6 @@ func (Ctx *Context) CpupoolCpuremoveCpumap(Poolid uint= 32, Cpumap Bitmap) (err er =20 // int libxl_cpupool_rename(libxl_ctx *ctx, const char *name, uint32_t poo= lid); func (Ctx *Context) CpupoolRename(Name string, Poolid uint32) (err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - name :=3D C.CString(Name) defer C.free(unsafe.Pointer(name)) =20 @@ -653,11 +637,6 @@ func (Ctx *Context) CpupoolRename(Name string, Poolid = uint32) (err error) { =20 // int libxl_cpupool_cpuadd_node(libxl_ctx *ctx, uint32_t poolid, int node= , int *cpus); func (Ctx *Context) CpupoolCpuaddNode(Poolid uint32, Node int) (Cpus int, = err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ccpus :=3D C.int(0) =20 ret :=3D C.libxl_cpupool_cpuadd_node(Ctx.ctx, C.uint32_t(Poolid), C.int(N= ode), &ccpus) @@ -673,11 +652,6 @@ func (Ctx *Context) CpupoolCpuaddNode(Poolid uint32, N= ode int) (Cpus int, err er =20 // int libxl_cpupool_cpuremove_node(libxl_ctx *ctx, uint32_t poolid, int n= ode, int *cpus); func (Ctx *Context) CpupoolCpuremoveNode(Poolid uint32, Node int) (Cpus in= t, err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ccpus :=3D C.int(0) =20 ret :=3D C.libxl_cpupool_cpuremove_node(Ctx.ctx, C.uint32_t(Poolid), C.in= t(Node), &ccpus) @@ -693,11 +667,6 @@ func (Ctx *Context) CpupoolCpuremoveNode(Poolid uint32= , Node int) (Cpus int, err =20 // int libxl_cpupool_movedomain(libxl_ctx *ctx, uint32_t poolid, uint32_t = domid); func (Ctx *Context) CpupoolMovedomain(Poolid uint32, Id Domid) (err error)= { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ret :=3D C.libxl_cpupool_movedomain(Ctx.ctx, C.uint32_t(Poolid), C.uint32= _t(Id)) if ret !=3D 0 { err =3D Error(-ret) @@ -857,60 +826,8 @@ func (bm Bitmap) String() (s string) { return } =20 -/* - * Context - */ -var Ctx Context - -func (Ctx *Context) IsOpen() bool { - return Ctx.ctx !=3D nil -} - -func (Ctx *Context) Open() (err error) { - if Ctx.ctx !=3D nil { - return - } - - Ctx.logger =3D C.xtl_createlogger_stdiostream(C.stderr, C.XTL_ERROR, 0) - if Ctx.logger =3D=3D nil { - err =3D fmt.Errorf("Cannot open stdiostream") - return - } - - ret :=3D C.libxl_ctx_alloc(&Ctx.ctx, C.LIBXL_VERSION, - 0, (*C.xentoollog_logger)(unsafe.Pointer(Ctx.logger))) - - if ret !=3D 0 { - err =3D Error(-ret) - } - return -} - -func (Ctx *Context) Close() (err error) { - ret :=3D C.libxl_ctx_free(Ctx.ctx) - Ctx.ctx =3D nil - - if ret !=3D 0 { - err =3D Error(-ret) - } - C.xtl_logger_destroy((*C.xentoollog_logger)(unsafe.Pointer(Ctx.logger))) - return -} - -func (Ctx *Context) CheckOpen() (err error) { - if Ctx.ctx =3D=3D nil { - err =3D fmt.Errorf("Context not opened") - } - return -} - //int libxl_get_max_cpus(libxl_ctx *ctx); func (Ctx *Context) GetMaxCpus() (maxCpus int, err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ret :=3D C.libxl_get_max_cpus(Ctx.ctx) if ret < 0 { err =3D Error(-ret) @@ -922,11 +839,6 @@ func (Ctx *Context) GetMaxCpus() (maxCpus int, err err= or) { =20 //int libxl_get_online_cpus(libxl_ctx *ctx); func (Ctx *Context) GetOnlineCpus() (onCpus int, err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ret :=3D C.libxl_get_online_cpus(Ctx.ctx) if ret < 0 { err =3D Error(-ret) @@ -938,10 +850,6 @@ func (Ctx *Context) GetOnlineCpus() (onCpus int, err e= rror) { =20 //int libxl_get_max_nodes(libxl_ctx *ctx); func (Ctx *Context) GetMaxNodes() (maxNodes int, err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } ret :=3D C.libxl_get_max_nodes(Ctx.ctx) if ret < 0 { err =3D Error(-ret) @@ -953,10 +861,6 @@ func (Ctx *Context) GetMaxNodes() (maxNodes int, err e= rror) { =20 //int libxl_get_free_memory(libxl_ctx *ctx, uint64_t *memkb); func (Ctx *Context) GetFreeMemory() (memkb uint64, err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } var cmem C.uint64_t ret :=3D C.libxl_get_free_memory(Ctx.ctx, &cmem) =20 @@ -972,10 +876,6 @@ func (Ctx *Context) GetFreeMemory() (memkb uint64, err= error) { =20 //int libxl_get_physinfo(libxl_ctx *ctx, libxl_physinfo *physinfo) func (Ctx *Context) GetPhysinfo() (physinfo *Physinfo, err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } var cphys C.libxl_physinfo C.libxl_physinfo_init(&cphys) defer C.libxl_physinfo_dispose(&cphys) @@ -993,11 +893,6 @@ func (Ctx *Context) GetPhysinfo() (physinfo *Physinfo,= err error) { =20 //const libxl_version_info* libxl_get_version_info(libxl_ctx *ctx); func (Ctx *Context) GetVersionInfo() (info *VersionInfo, err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - var cinfo *C.libxl_version_info =20 cinfo =3D C.libxl_get_version_info(Ctx.ctx) @@ -1008,11 +903,6 @@ func (Ctx *Context) GetVersionInfo() (info *VersionIn= fo, err error) { } =20 func (Ctx *Context) DomainInfo(Id Domid) (di *Dominfo, err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - var cdi C.libxl_dominfo C.libxl_dominfo_init(&cdi) defer C.libxl_dominfo_dispose(&cdi) @@ -1030,11 +920,6 @@ func (Ctx *Context) DomainInfo(Id Domid) (di *Dominfo= , err error) { } =20 func (Ctx *Context) DomainUnpause(Id Domid) (err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ret :=3D C.libxl_domain_unpause(Ctx.ctx, C.uint32_t(Id), nil) =20 if ret !=3D 0 { @@ -1045,11 +930,6 @@ func (Ctx *Context) DomainUnpause(Id Domid) (err erro= r) { =20 //int libxl_domain_pause(libxl_ctx *ctx, uint32_t domain); func (Ctx *Context) DomainPause(id Domid) (err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ret :=3D C.libxl_domain_pause(Ctx.ctx, C.uint32_t(id), nil) =20 if ret !=3D 0 { @@ -1060,11 +940,6 @@ func (Ctx *Context) DomainPause(id Domid) (err error)= { =20 //int libxl_domain_shutdown(libxl_ctx *ctx, uint32_t domid); func (Ctx *Context) DomainShutdown(id Domid) (err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ret :=3D C.libxl_domain_shutdown(Ctx.ctx, C.uint32_t(id), nil) =20 if ret !=3D 0 { @@ -1075,11 +950,6 @@ func (Ctx *Context) DomainShutdown(id Domid) (err err= or) { =20 //int libxl_domain_reboot(libxl_ctx *ctx, uint32_t domid); func (Ctx *Context) DomainReboot(id Domid) (err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - ret :=3D C.libxl_domain_reboot(Ctx.ctx, C.uint32_t(id), nil) =20 if ret !=3D 0 { @@ -1091,11 +961,6 @@ func (Ctx *Context) DomainReboot(id Domid) (err error= ) { //libxl_dominfo * libxl_list_domain(libxl_ctx*, int *nb_domain_out); //void libxl_dominfo_list_free(libxl_dominfo *list, int nb_domain); func (Ctx *Context) ListDomain() (glist []Dominfo) { - err :=3D Ctx.CheckOpen() - if err !=3D nil { - return - } - var nbDomain C.int clist :=3D C.libxl_list_domain(Ctx.ctx, &nbDomain) defer C.libxl_dominfo_list_free(clist, nbDomain) @@ -1118,11 +983,6 @@ func (Ctx *Context) ListDomain() (glist []Dominfo) { // int *nb_vcpu, int *nr_cpus_out); //void libxl_vcpuinfo_list_free(libxl_vcpuinfo *, int nr_vcpus); func (Ctx *Context) ListVcpu(id Domid) (glist []Vcpuinfo) { - err :=3D Ctx.CheckOpen() - if err !=3D nil { - return - } - var nbVcpu C.int var nrCpu C.int =20 @@ -1153,11 +1013,6 @@ func (ct ConsoleType) String() (str string) { //int libxl_console_get_tty(libxl_ctx *ctx, uint32_t domid, int cons_num, //libxl_console_type type, char **path); func (Ctx *Context) ConsoleGetTty(id Domid, consNum int, conType ConsoleTy= pe) (path string, err error) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - var cpath *C.char ret :=3D C.libxl_console_get_tty(Ctx.ctx, C.uint32_t(id), C.int(consNum),= C.libxl_console_type(conType), &cpath) if ret !=3D 0 { @@ -1173,11 +1028,6 @@ func (Ctx *Context) ConsoleGetTty(id Domid, consNum = int, conType ConsoleType) (p //int libxl_primary_console_get_tty(libxl_ctx *ctx, uint32_t domid_vm, // char **path); func (Ctx *Context) PrimaryConsoleGetTty(domid uint32) (path string, err e= rror) { - err =3D Ctx.CheckOpen() - if err !=3D nil { - return - } - var cpath *C.char ret :=3D C.libxl_primary_console_get_tty(Ctx.ctx, C.uint32_t(domid), &cpa= th) if ret !=3D 0 { --=20 2.17.1 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel From nobody Tue May 7 14:51:30 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=1577114343; cv=none; d=zohomail.com; s=zohoarc; b=jhPQ0ntbq0WBtJG24voPTZYT5Y5sbE3pBOFu8wMP/mmv486v69syOkHTz1eCAKdq4PQZwCAG1UcNyr/rgHTP67XDEdVzA43c6lVOfbVbq27kSECAmhnqodUvCRZRLRSgjh1KoPn6/XEbVWlp15tsyaUzonimbfUel4jBypbq6z0= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1577114343; 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=hle62Fph7nFi2h4CNqcZxnOP2upLxp91GFzP0fYt7OY=; b=KEdmtBWg3MwbTHgeFHg3LHWd1RWIKc3uTh4p+QlwPHmiuo62x3h1JTxpFST1uvKytiYckV5apHniZwCxEFRPe0oQioQogsBJCauRd9OwNK40pk77wSq4LSIE/4hnuUhh4Jv7yeJ0XsZCvG5i1ZHxv0d7w/Iz6OwdC23Q/OEKhTM= 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 1577114343746707.0557935803738; Mon, 23 Dec 2019 07:19:03 -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 1ijPTN-0006Rs-Re; Mon, 23 Dec 2019 15:18:17 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1ijPTM-0006RE-He for xen-devel@lists.xenproject.org; Mon, 23 Dec 2019 15:18:16 +0000 Received: from mail-qv1-xf44.google.com (unknown [2607:f8b0:4864:20::f44]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 6488a966-2597-11ea-88e7-bc764e2007e4; Mon, 23 Dec 2019 15:17:54 +0000 (UTC) Received: by mail-qv1-xf44.google.com with SMTP id f16so6465194qvi.4 for ; Mon, 23 Dec 2019 07:17:54 -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 u15sm5823907qku.67.2019.12.23.07.17.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 23 Dec 2019 07:17:53 -0800 (PST) X-Inumbo-ID: 6488a966-2597-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=F/xV9O13I7GQ/UCRCjsUvyaympRarisj/rLEyIKgRFk=; b=pHMlx/8LE4XvEKQdtXEU5JugHWGVSHtPu5CB0TuFY+vwS7ud3dp6GCiMKqPWuoIc0J KeMrfC+AfndLLXMxb1XFU/WAgqW23rF/kZbi4q/eNA1VSv0W0FBUhK5irNio9wnHZdYU K3v0/jm5/q0IWBg9cQHMYRrLYeSJwgj9bRzWfefPjD30Z3TLNe/xvDCdGICKMnlGu3N8 q2O1oJD/RVEeOfQx55nRP9qKxuQeEyDWWCXT+sejzxosO1bMJ8bvxuhoSwa32D0vcCcK 0pJPq2e3lI13cUd2GrcPciO97d8HvvxxqafyfIqdYluGT1qPX0TB9Qn71dty/eCZJCzX uZyw== 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=F/xV9O13I7GQ/UCRCjsUvyaympRarisj/rLEyIKgRFk=; b=KMmxKm1iD+ddxhpK42nDdmfhnyUq1LgM+o3NSsZZpIxmCSYZDXnZldO6xAbggenAV1 wAaOUXxtcvG1r1C7ZslVKyQDlwtcFhEt4BhmvJAWrzSIVJ2pfoEGky6EsVNBldJa2Otd OWfgOQI57aT2dVfQgSzA19dnadxIvOiQJ3xd9kMLFaAAMfNt6p30tzIGtAhof9yULQ/u uzlgubvFAX35aSkGaOXzQf/1LqIYt5zVOC9VmPw13GulyPfUakEqLgDDpNjLw18bKOpO Rp/giE7FKjjfOQ+9gonis23ziVGg7I+q35vLrQY3b9I1Lfwz6bBvZqZ3uanGAK6+ho13 axpQ== X-Gm-Message-State: APjAAAUampyArhidBPb109Nj90sOZnjW9hQgzp4qRWblybT32SYXHWRg CfNqNom667Hfw7keVGDkn34j5YAo X-Google-Smtp-Source: APXvYqwZ8k+GIdIvG464d7bb9g5hI8ovmp+u+tGC7954ukk610VnYppuqyyat1ONvNOLglX4BesNEQ== X-Received: by 2002:a0c:c389:: with SMTP id o9mr25177144qvi.232.1577114273901; Mon, 23 Dec 2019 07:17:53 -0800 (PST) From: Nick Rosbrook X-Google-Original-From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Mon, 23 Dec 2019 10:17:07 -0500 Message-Id: X-Mailer: git-send-email 2.17.1 In-Reply-To: References: In-Reply-To: References: Subject: [Xen-devel] [PATCH v4 6/6] golang/xenlight: add error return type to Context.Cpupoolinfo X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Nick Rosbrook , Ian Jackson , kerriganb@ainfosec.com, George Dunlap , Wei Liu 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) A previous commit that removed Context.CheckOpen revealed an ineffectual assignent to err in Context.Cpupoolinfo, as there is no error return type. Since it appears that the intent is to return an error here, add an error return value to the function signature. Signed-off-by: Nick Rosbrook Reviewed-by: George Dunlap --- tools/golang/xenlight/xenlight.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/golang/xenlight/xenlight.go b/tools/golang/xenlight/xenl= ight.go index 5f14cab6ce..237f26bce9 100644 --- a/tools/golang/xenlight/xenlight.go +++ b/tools/golang/xenlight/xenlight.go @@ -504,17 +504,17 @@ func (Ctx *Context) ListCpupool() (list []Cpupoolinfo= ) { } =20 // int libxl_cpupool_info(libxl_ctx *ctx, libxl_cpupoolinfo *info, uint32_= t poolid); -func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool Cpupoolinfo) { +func (Ctx *Context) CpupoolInfo(Poolid uint32) (pool Cpupoolinfo, err erro= r) { var c_cpupool C.libxl_cpupoolinfo =20 ret :=3D C.libxl_cpupool_info(Ctx.ctx, &c_cpupool, C.uint32_t(Poolid)) if ret !=3D 0 { - //err =3D Error(-ret) + err =3D Error(-ret) return } defer C.libxl_cpupoolinfo_dispose(&c_cpupool) =20 - _ =3D pool.fromC(&c_cpupool) + err =3D pool.fromC(&c_cpupool) =20 return } --=20 2.17.1 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel