From patchwork Mon Oct 7 15:13:05 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nick Rosbrook X-Patchwork-Id: 11177805 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 6714313BD for ; Mon, 7 Oct 2019 15:16:13 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 372BE2053B for ; Mon, 7 Oct 2019 15:16:13 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="OpENF7qE" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 372BE2053B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iHUil-0007Yn-Nq; Mon, 07 Oct 2019 15:14:47 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iHUik-0007Xn-Pa for xen-devel@lists.xenproject.org; Mon, 07 Oct 2019 15:14:46 +0000 X-Inumbo-ID: 09b4cb14-e915-11e9-80e3-bc764e2007e4 Received: from mail-qk1-x732.google.com (unknown [2607:f8b0:4864:20::732]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 09b4cb14-e915-11e9-80e3-bc764e2007e4; Mon, 07 Oct 2019 15:13:37 +0000 (UTC) Received: by mail-qk1-x732.google.com with SMTP id z67so12870762qkb.12 for ; Mon, 07 Oct 2019 08:13:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=2Mq8gnqYu6RvzZZ4Dv6t9X9maxsR1srlDfTSM9jGW7Q=; b=OpENF7qEKrFeEL7WT8v2ehLIoWRAW4kbstAzmOhZDIkQLqowecFAWJNVjvFA9x/wBP rdpQKS2S8nWQWe1Sv2/GgvMSMx7mhdAPvU5QoW2+3dSNOica3IvbMkozUCS5R0+AatWQ uAeX0LAJ7JDxOuv7lHiL7laP3RjUCr+6rXLeoovJpNQ4lKRGfn+Knb9Hyrcm/3oeEiLs oEinaMfIoc90cJWzGkr7xIazAR2guWfbwV6DXDqLPN10Yq/zQB3FUSyLwlBb9DYDeVr/ y6HgI5LzHYqJ5aXUPcveczl7d4o2I+dNPtno6EgoRLtE2N1j7CLWJEfMMnImopaOrBnX 5jvw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=2Mq8gnqYu6RvzZZ4Dv6t9X9maxsR1srlDfTSM9jGW7Q=; b=E338YNQl9pppEG6r/E0rQYPg3jojtduckRLnE+5qiHxf3BAj/NoAzUHqeG6P9uV+nB muDPvfq+eKHQk7Cmt5VNnLhyxYieWX3n+6fabTlgsl8pxY2ytHLXl+y/rcrVxBUv2P+0 cA8pxYJS1Px2ujDrWtB5j+tI+e0XklAT3HMGazph2HTGz/ZdkMSZJnjblscGv6iB1HIW /K77ABwNAkTiii8SGmI0L5FEo/rzjkyn/b3wg6s/tuuZB/kZCbWnhoEa2ofxk3rD8fGo KjxgzGIUfykzif9z9b4DD1487G4UYjPPDX1m/99g6BScMeN+bShx+hTZ51UFzXFXuI/v 1GdQ== X-Gm-Message-State: APjAAAUrDe/kvOA+5Udj9Eo6b5i6zzJJM2Z/BJGn/7tyZZI7+ufFWndm UTfnjiZ0ycZXlfU3DcdQabu2Wz08 X-Google-Smtp-Source: APXvYqymMQd3lnDTI8TCz1bPudeUNG910LHgtmoYO81IRZjlnQwbP5r7aAjrPVJZircRkQhGw1iBaQ== X-Received: by 2002:a05:620a:1307:: with SMTP id o7mr24107875qkj.165.1570461217065; Mon, 07 Oct 2019 08:13:37 -0700 (PDT) Received: from five.crux.rad.ainfosec.com (209-217-208-226.northland.net. [209.217.208.226]) by smtp.googlemail.com with ESMTPSA id c185sm8354313qkg.74.2019.10.07.08.13.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 07 Oct 2019 08:13:36 -0700 (PDT) From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Mon, 7 Oct 2019 11:13:05 -0400 Message-Id: <006339543b7f837eee549482a20e8521e6f8ec4b.1570456846.git.rosbrookn@ainfosec.com> X-Mailer: git-send-email 2.19.1 In-Reply-To: References: MIME-Version: 1.0 Subject: [Xen-devel] [PATCH 18/24] 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 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" From: Nick Rosbrook Signed-off-by: Nick Rosbrook --- Cc: George Dunlap Cc: Ian Jackson Cc: Wei Liu tools/golang/xenlight/gengotypes.py | 39 ++- tools/golang/xenlight/xenlight_helpers.go | 300 ++++++++++++++++++++++ 2 files changed, 338 insertions(+), 1 deletion(-) diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/gengotypes.py index ececaafd72..2b620f0ae9 100644 --- a/tools/golang/xenlight/gengotypes.py +++ b/tools/golang/xenlight/gengotypes.py @@ -257,7 +257,7 @@ def xenlight_golang_define_from_C(ty = None, typename = None, nested = False): for f in ty.fields: if f.type.typename is not None: if isinstance(f.type, idl.Array): - # TODO + s += xenlight_golang_array_from_C(f) continue gotypename = xenlight_golang_fmt_name(f.type.typename) @@ -420,6 +420,43 @@ def xenlight_golang_union_fields_from_C(ty = None): return s +def xenlight_golang_array_from_C(ty = None): + """ + Convert C array to Go slice using the method + described here: + + https://github.com/golang/go/wiki/cgo#turning-c-arrays-into-go-slices + """ + s = '' + + gotypename = xenlight_golang_fmt_name(ty.type.elem_type.typename) + goname = xenlight_golang_fmt_name(ty.name) + ctypename = ty.type.elem_type.typename + cname = ty.name + cslice = 'c{}'.format(goname) + clenvar = ty.type.lenvar.name + golenvar = xenlight_golang_fmt_name(clenvar,exported=False) + + s += '{} := int(xc.{})\n'.format(golenvar, clenvar) + s += '{} := '.format(cslice) + s +='(*[1<<28]C.{})(unsafe.Pointer(xc.{}))[:{}:{}]\n'.format(ctypename, cname, + golenvar, golenvar) + s += 'x.{} = make([]{}, {})\n'.format(goname, gotypename, golenvar) + s += 'for i, v := range {} {{\n'.format(cslice) + + is_enum = isinstance(ty.type.elem_type,idl.Enumeration) + if gotypename in go_builtin_types or is_enum: + s += 'x.{}[i] = {}(v)\n'.format(goname, gotypename) + else: + s += 'var e {}\n'.format(gotypename) + s += 'if err := e.fromC(&v); err != nil {\n' + s += 'return err }\n' + s += 'x.{}[i] = e\n'.format(goname) + + s += '}\n' + + return s + def xenlight_golang_fmt_name(name, exported = True): """ Take a given type name and return an diff --git a/tools/golang/xenlight/xenlight_helpers.go b/tools/golang/xenlight/xenlight_helpers.go index b8abef8068..2cdc1bbdc9 100644 --- a/tools/golang/xenlight/xenlight_helpers.go +++ b/tools/golang/xenlight/xenlight_helpers.go @@ -382,6 +382,16 @@ func (x *SchedParams) fromC(xc *C.libxl_sched_params) error { func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error { x.Sched = Scheduler(xc.sched) + numVcpus := int(xc.num_vcpus) + cVcpus := (*[1 << 28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:numVcpus:numVcpus] + x.Vcpus = make([]SchedParams, numVcpus) + for i, v := range cVcpus { + var e SchedParams + if err := e.fromC(&v); err != nil { + return err + } + x.Vcpus[i] = e + } return nil } @@ -399,6 +409,12 @@ func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error { func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error { x.Memkb = uint64(xc.memkb) + numDistances := int(xc.num_distances) + cDistances := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.distances))[:numDistances:numDistances] + x.Distances = make([]uint32, numDistances) + for i, v := range cDistances { + x.Distances[i] = uint32(v) + } x.Pnode = uint32(xc.pnode) var bitmapVcpus Bitmap if err := bitmapVcpus.fromC(&xc.vcpus); err != nil { @@ -431,6 +447,26 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error { return err } x.Nodemap = bitmapNodemap + numVcpuHardAffinity := int(xc.num_vcpu_hard_affinity) + cVcpuHardAffinity := (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_hard_affinity))[:numVcpuHardAffinity:numVcpuHardAffinity] + x.VcpuHardAffinity = make([]Bitmap, numVcpuHardAffinity) + for i, v := range cVcpuHardAffinity { + var e Bitmap + if err := e.fromC(&v); err != nil { + return err + } + x.VcpuHardAffinity[i] = e + } + numVcpuSoftAffinity := int(xc.num_vcpu_soft_affinity) + cVcpuSoftAffinity := (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_soft_affinity))[:numVcpuSoftAffinity:numVcpuSoftAffinity] + x.VcpuSoftAffinity = make([]Bitmap, numVcpuSoftAffinity) + for i, v := range cVcpuSoftAffinity { + var e Bitmap + if err := e.fromC(&v); err != nil { + return err + } + x.VcpuSoftAffinity[i] = e + } var defboolNumaPlacement Defbool if err := defboolNumaPlacement.fromC(&xc.numa_placement); err != nil { return err @@ -460,6 +496,16 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error { } x.Cpuid = cpuidPolicyListCpuid x.BlkdevStart = C.GoString(xc.blkdev_start) + numVnumaNodes := int(xc.num_vnuma_nodes) + cVnumaNodes := (*[1 << 28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_nodes))[:numVnumaNodes:numVnumaNodes] + x.VnumaNodes = make([]VnodeInfo, numVnumaNodes) + for i, v := range cVnumaNodes { + var e VnodeInfo + if err := e.fromC(&v); err != nil { + return err + } + x.VnumaNodes[i] = e + } x.MaxGrantFrames = uint32(xc.max_grant_frames) x.MaxMaptrackFrames = uint32(xc.max_maptrack_frames) x.DeviceModelVersion = DeviceModelVersion(xc.device_model_version) @@ -492,6 +538,32 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error { return err } x.SchedParams = domainSchedParamsSchedParams + numIoports := int(xc.num_ioports) + cIoports := (*[1 << 28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports))[:numIoports:numIoports] + x.Ioports = make([]IoportRange, numIoports) + for i, v := range cIoports { + var e IoportRange + if err := e.fromC(&v); err != nil { + return err + } + x.Ioports[i] = e + } + numIrqs := int(xc.num_irqs) + cIrqs := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:numIrqs:numIrqs] + x.Irqs = make([]uint32, numIrqs) + for i, v := range cIrqs { + x.Irqs[i] = uint32(v) + } + numIomem := int(xc.num_iomem) + cIomem := (*[1 << 28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:numIomem:numIomem] + x.Iomem = make([]IomemRange, numIomem) + for i, v := range cIomem { + var e IomemRange + if err := e.fromC(&v); err != nil { + return err + } + x.Iomem[i] = e + } var defboolClaimMode Defbool if err := defboolClaimMode.fromC(&xc.claim_mode); err != nil { return err @@ -982,10 +1054,32 @@ func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdispl) error { x.BackendDomname = C.GoString(xc.backend_domname) x.Devid = Devid(xc.devid) x.BeAlloc = bool(xc.be_alloc) + numConnectors := int(xc.num_connectors) + cConnectors := (*[1 << 28]C.libxl_connector_param)(unsafe.Pointer(xc.connectors))[:numConnectors:numConnectors] + x.Connectors = make([]ConnectorParam, numConnectors) + for i, v := range cConnectors { + var e ConnectorParam + if err := e.fromC(&v); err != nil { + return err + } + x.Connectors[i] = e + } return nil } func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error { + numSampleRates := int(xc.num_sample_rates) + cSampleRates := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.sample_rates))[:numSampleRates:numSampleRates] + x.SampleRates = make([]uint32, numSampleRates) + for i, v := range cSampleRates { + x.SampleRates[i] = uint32(v) + } + numSampleFormats := int(xc.num_sample_formats) + cSampleFormats := (*[1 << 28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc.sample_formats))[:numSampleFormats:numSampleFormats] + x.SampleFormats = make([]VsndPcmFormat, numSampleFormats) + for i, v := range cSampleFormats { + x.SampleFormats[i] = VsndPcmFormat(v) + } x.ChannelsMin = uint32(xc.channels_min) x.ChannelsMax = uint32(xc.channels_max) x.BufferSize = uint32(xc.buffer_size) @@ -1010,6 +1104,16 @@ func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error { return err } x.Params = vsndParamsParams + numVsndStreams := int(xc.num_vsnd_streams) + cStreams := (*[1 << 28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams] + x.Streams = make([]VsndStream, numVsndStreams) + for i, v := range cStreams { + var e VsndStream + if err := e.fromC(&v); err != nil { + return err + } + x.Streams[i] = e + } return nil } @@ -1024,6 +1128,16 @@ func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error { return err } x.Params = vsndParamsParams + numVsndPcms := int(xc.num_vsnd_pcms) + cPcms := (*[1 << 28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms] + x.Pcms = make([]VsndPcm, numVsndPcms) + for i, v := range cPcms { + var e VsndPcm + if err := e.fromC(&v); err != nil { + return err + } + x.Pcms[i] = e + } return nil } @@ -1038,6 +1152,156 @@ func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error { return err } x.BInfo = domainBuildInfoBInfo + numDisks := int(xc.num_disks) + cDisks := (*[1 << 28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:numDisks:numDisks] + x.Disks = make([]DeviceDisk, numDisks) + for i, v := range cDisks { + var e DeviceDisk + if err := e.fromC(&v); err != nil { + return err + } + x.Disks[i] = e + } + numNics := int(xc.num_nics) + cNics := (*[1 << 28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:numNics:numNics] + x.Nics = make([]DeviceNic, numNics) + for i, v := range cNics { + var e DeviceNic + if err := e.fromC(&v); err != nil { + return err + } + x.Nics[i] = e + } + numPcidevs := int(xc.num_pcidevs) + cPcidevs := (*[1 << 28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))[:numPcidevs:numPcidevs] + x.Pcidevs = make([]DevicePci, numPcidevs) + for i, v := range cPcidevs { + var e DevicePci + if err := e.fromC(&v); err != nil { + return err + } + x.Pcidevs[i] = e + } + numRdms := int(xc.num_rdms) + cRdms := (*[1 << 28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:numRdms:numRdms] + x.Rdms = make([]DeviceRdm, numRdms) + for i, v := range cRdms { + var e DeviceRdm + if err := e.fromC(&v); err != nil { + return err + } + x.Rdms[i] = e + } + numDtdevs := int(xc.num_dtdevs) + cDtdevs := (*[1 << 28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))[:numDtdevs:numDtdevs] + x.Dtdevs = make([]DeviceDtdev, numDtdevs) + for i, v := range cDtdevs { + var e DeviceDtdev + if err := e.fromC(&v); err != nil { + return err + } + x.Dtdevs[i] = e + } + numVfbs := int(xc.num_vfbs) + cVfbs := (*[1 << 28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:numVfbs:numVfbs] + x.Vfbs = make([]DeviceVfb, numVfbs) + for i, v := range cVfbs { + var e DeviceVfb + if err := e.fromC(&v); err != nil { + return err + } + x.Vfbs[i] = e + } + numVkbs := int(xc.num_vkbs) + cVkbs := (*[1 << 28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:numVkbs:numVkbs] + x.Vkbs = make([]DeviceVkb, numVkbs) + for i, v := range cVkbs { + var e DeviceVkb + if err := e.fromC(&v); err != nil { + return err + } + x.Vkbs[i] = e + } + numVtpms := int(xc.num_vtpms) + cVtpms := (*[1 << 28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:numVtpms:numVtpms] + x.Vtpms = make([]DeviceVtpm, numVtpms) + for i, v := range cVtpms { + var e DeviceVtpm + if err := e.fromC(&v); err != nil { + return err + } + x.Vtpms[i] = e + } + numP9S := int(xc.num_p9s) + cP9S := (*[1 << 28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:numP9S:numP9S] + x.P9S = make([]DeviceP9, numP9S) + for i, v := range cP9S { + var e DeviceP9 + if err := e.fromC(&v); err != nil { + return err + } + x.P9S[i] = e + } + numPvcallsifs := int(xc.num_pvcallsifs) + cPvcallsifs := (*[1 << 28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.pvcallsifs))[:numPvcallsifs:numPvcallsifs] + x.Pvcallsifs = make([]DevicePvcallsif, numPvcallsifs) + for i, v := range cPvcallsifs { + var e DevicePvcallsif + if err := e.fromC(&v); err != nil { + return err + } + x.Pvcallsifs[i] = e + } + numVdispls := int(xc.num_vdispls) + cVdispls := (*[1 << 28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispls))[:numVdispls:numVdispls] + x.Vdispls = make([]DeviceVdispl, numVdispls) + for i, v := range cVdispls { + var e DeviceVdispl + if err := e.fromC(&v); err != nil { + return err + } + x.Vdispls[i] = e + } + numVsnds := int(xc.num_vsnds) + cVsnds := (*[1 << 28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:numVsnds:numVsnds] + x.Vsnds = make([]DeviceVsnd, numVsnds) + for i, v := range cVsnds { + var e DeviceVsnd + if err := e.fromC(&v); err != nil { + return err + } + x.Vsnds[i] = e + } + numChannels := int(xc.num_channels) + cChannels := (*[1 << 28]C.libxl_device_channel)(unsafe.Pointer(xc.channels))[:numChannels:numChannels] + x.Channels = make([]DeviceChannel, numChannels) + for i, v := range cChannels { + var e DeviceChannel + if err := e.fromC(&v); err != nil { + return err + } + x.Channels[i] = e + } + numUsbctrls := int(xc.num_usbctrls) + cUsbctrls := (*[1 << 28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbctrls))[:numUsbctrls:numUsbctrls] + x.Usbctrls = make([]DeviceUsbctrl, numUsbctrls) + for i, v := range cUsbctrls { + var e DeviceUsbctrl + if err := e.fromC(&v); err != nil { + return err + } + x.Usbctrls[i] = e + } + numUsbdevs := int(xc.num_usbdevs) + cUsbdevs := (*[1 << 28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdevs))[:numUsbdevs:numUsbdevs] + x.Usbdevs = make([]DeviceUsbdev, numUsbdevs) + for i, v := range cUsbdevs { + var e DeviceUsbdev + if err := e.fromC(&v); err != nil { + return err + } + x.Usbdevs[i] = e + } x.OnPoweroff = ActionOnShutdown(xc.on_poweroff) x.OnReboot = ActionOnShutdown(xc.on_reboot) x.OnWatchdog = ActionOnShutdown(xc.on_watchdog) @@ -1171,6 +1435,16 @@ func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error { x.Devid = Devid(xc.devid) x.State = int(xc.state) x.BeAlloc = bool(xc.be_alloc) + numConnectors := int(xc.num_connectors) + cConnectors := (*[1 << 28]C.libxl_connectorinfo)(unsafe.Pointer(xc.connectors))[:numConnectors:numConnectors] + x.Connectors = make([]Connectorinfo, numConnectors) + for i, v := range cConnectors { + var e Connectorinfo + if err := e.fromC(&v); err != nil { + return err + } + x.Connectors[i] = e + } return nil } @@ -1181,6 +1455,16 @@ func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error { } func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error { + numVsndStreams := int(xc.num_vsnd_streams) + cStreams := (*[1 << 28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams] + x.Streams = make([]Streaminfo, numVsndStreams) + for i, v := range cStreams { + var e Streaminfo + if err := e.fromC(&v); err != nil { + return err + } + x.Streams[i] = e + } return nil } @@ -1191,6 +1475,16 @@ func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error { x.FrontendId = uint32(xc.frontend_id) x.Devid = Devid(xc.devid) x.State = int(xc.state) + numVsndPcms := int(xc.num_vsnd_pcms) + cPcms := (*[1 << 28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms] + x.Pcms = make([]Pcminfo, numVsndPcms) + for i, v := range cPcms { + var e Pcminfo + if err := e.fromC(&v); err != nil { + return err + } + x.Pcms[i] = e + } return nil } @@ -1209,6 +1503,12 @@ func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error { func (x *Numainfo) fromC(xc *C.libxl_numainfo) error { x.Size = uint64(xc.size) x.Free = uint64(xc.free) + numDists := int(xc.num_dists) + cDists := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.dists))[:numDists:numDists] + x.Dists = make([]uint32, numDists) + for i, v := range cDists { + x.Dists[i] = uint32(v) + } return nil }