From nobody Sat May 4 17:16:37 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=1583179939; cv=none; d=zohomail.com; s=zohoarc; b=FuYmhBSw2n6BtYZ8dwgIl0CTe9GfG/1el98nB/aY7SrDqk4Kn/C6KWLyoYhoXo5v0YM4EETJLi6zRQKnvI0H8FcqPL4GSTqfMH37ugUxCw54NdEJa5h9t3NUIAumDUQjD1FJOC65KylYvg+Uz8EytgKZxBXAlH0fJMwhqhUbiaI= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1583179939; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:List-Subscribe:List-Post:List-Id:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Sender:Subject:To; bh=OaopUDxUbDUilBWYCurDCt1a83LOaz1uXdMwHg6IHhE=; b=Z6BPnsAoQQTKG0p1rTVv3KSwamPV1uj2fru4YG91BgSCkxO415SL87+Wju3oBCsMwJiMSFjYeUgPD3wVruf2GBD7oWJOMSouVLRcuXt5p64gqdOAENW/CdJj9dTF9/ctTitkZKM9vM9kYeBH0KyPYCN74rVIOxA7ux5CdM12G8w= 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 1583179939399512.4919479712157; Mon, 2 Mar 2020 12:12:19 -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 1j8rPD-0001O8-5w; Mon, 02 Mar 2020 20:11:11 +0000 Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1j8rPB-0001O3-WE for xen-devel@lists.xenproject.org; Mon, 02 Mar 2020 20:11:10 +0000 Received: from mail-yw1-f44.google.com (unknown [209.85.161.44]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTPS id f2b42c4b-5cc1-11ea-9ff6-12813bfff9fa; Mon, 02 Mar 2020 20:11:06 +0000 (UTC) Received: by mail-yw1-f44.google.com with SMTP id y72so1085528ywg.3 for ; Mon, 02 Mar 2020 12:11:06 -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 s185sm890490ywd.73.2020.03.02.12.11.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 02 Mar 2020 12:11:01 -0800 (PST) X-Inumbo-ID: f2b42c4b-5cc1-11ea-9ff6-12813bfff9fa DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id; bh=Ljh15I+NnbiOdQAiKkDPi5D9dY+Wl7d4cf7nQqn9ZFM=; b=rYfdjBGYs9zpoiJip9ZifEOKhirQLfKPO5UqO3k85RID7mpyeb05AtaRJ8aZUPh/H8 aDEUkpT/a1xCHYgWLy8RcTuY4wxe04I450fB76QMT+l0KQnzUI8ByS56E43fLo2oVu8J LQuqW2ZMZp7AzcWIuBuI9Pxd7LVqutpkeILFqw9PfCmQpaN3m1Hz86PMkDkKI5ogCm9u SIL0RwBIeatq/giMaGnhpX4m6078wgv5Nbn0C4kcQ2J2DZyLx2h5+cqT8ZIuZcFg0q6Q Kfzc0AWjBoAEC3g8aaubGlN3jls3TklO1DTwD/RFUWNc1E3T5vDsmn0z7AadA17Nsr4F pT2A== 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; bh=Ljh15I+NnbiOdQAiKkDPi5D9dY+Wl7d4cf7nQqn9ZFM=; b=gjCb1KOGPnfDkbs3K6vvzVe683gOZOB8fH5yQxWnHW08k3dcksijt3gdFnv5hb4Ugz tlX0mFMYPNaXrzXs5vtiFWukiwSeah/yBhIAifupWMoevWz0plzgwYnGszWU9N/YyaQV CRapHplqpLcpZOOcKQFV35Jmmagu2ZXscj8n2B2LR8S1/l98Ck66l1+p8cnIfk2PwFxj IabvnM1oSFD6flQtZ87o7pDP7aS2fgpHaj4/eZhMSUmfyHO4xYBrAqHKEC1DgZPX0HbQ ZJK8sEvrIZ61x0FRceVdlR4jR2nVnkOAKIz/yJ7qjS8nhzbphyG7U2LcgkPEi43lEhBH ZwXQ== X-Gm-Message-State: ANhLgQ3bFMY3VTAb1N3kQrb6gB9BXUcf+9V+aZ5Jh1mekpyFjFRsovXQ RCV/VEXkpSikhG6tPNF/pLyg1ZMG X-Google-Smtp-Source: ADFU+vvxZHnGaYdyGv/SRkT7DOIWrsdoK0V6JT//k3EPn7r+HY72vACGGK7mZakR1VNXhBjPFBjXKQ== X-Received: by 2002:a81:5655:: with SMTP id k82mr1044309ywb.363.1583179863160; Mon, 02 Mar 2020 12:11:03 -0800 (PST) From: Nick Rosbrook X-Google-Original-From: Nick Rosbrook To: xen-devel@lists.xenproject.org Date: Mon, 2 Mar 2020 15:10:24 -0500 Message-Id: X-Mailer: git-send-email 2.17.1 Subject: [Xen-devel] [PATCH v2] golang/xenlight: implement constructor generation X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Nick Rosbrook , Ian Jackson , George Dunlap , Wei Liu MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Generate constructors for generated Go types. Call libxl__init so the Go type can be properly initialized. If a type has a keyed union field, add a parameter to the function signature to set the key variable, and call the init function for the keyed union. Signed-off-by: Nick Rosbrook Reviewed-by: George Dunlap --- tools/golang/xenlight/gengotypes.py | 72 ++ tools/golang/xenlight/helpers.gen.go | 1060 +++++++++++++++++++++++++- 2 files changed, 1114 insertions(+), 18 deletions(-) diff --git a/tools/golang/xenlight/gengotypes.py b/tools/golang/xenlight/ge= ngotypes.py index b09cffb829..f81271f3c0 100644 --- a/tools/golang/xenlight/gengotypes.py +++ b/tools/golang/xenlight/gengotypes.py @@ -225,6 +225,9 @@ def xenlight_golang_generate_helpers(path =3D None, typ= es =3D None, comment =3D None): if not isinstance(ty, idl.Struct): continue =20 + f.write(xenlight_golang_define_constructor(ty)) + f.write('\n') + (fdef, extras) =3D xenlight_golang_define_from_C(ty) =20 f.write(fdef) @@ -619,6 +622,75 @@ def xenlight_golang_array_to_C(ty =3D None): =20 return s =20 +def xenlight_golang_define_constructor(ty =3D None): + s =3D '' + + ctypename =3D ty.typename + gotypename =3D xenlight_golang_fmt_name(ctypename) + + # Since this func is exported, add a comment as per Go conventions. + s +=3D '// New{} returns an instance of {}'.format(gotypename,gotypena= me) + s +=3D ' initialized with defaults.\n' + + # If a struct has a keyed union, an extra argument is + # required in the function signature, and an extra _init + # call is needed. + params =3D [] + init_fns =3D [] + + # Add call to parent init_fn first. + init_fns.append('C.{}(&xc)'.format(ty.init_fn)) + + for f in ty.fields: + if not isinstance(f.type, idl.KeyedUnion): + continue + + param =3D f.type.keyvar + + param_ctype =3D param.type.typename + param_gotype =3D xenlight_golang_fmt_name(param_ctype) + param_goname =3D xenlight_golang_fmt_name(param.name,exported=3DFa= lse) + + # Serveral keyed unions use 'type' as the key variable name. In + # that case, prepend the first letter of the Go type name. + if param_goname =3D=3D 'type': + param_goname =3D '{}type'.format(param_gotype.lower()[0]) + + # Add call to keyed union's init_fn. + init_fns.append('C.{}_{}(&xc, C.{}({}))'.format(ty.init_fn, + param.name, + param_ctype, + param_goname)) + + # Add to params list. + params.append('{} {}'.format(param_goname, param_gotype)) + + # Define function + s +=3D 'func New{}({}) (*{}, error) {{\n'.format(gotypename, + ','.join(params), + gotypename) + + # Declare variables. + s +=3D 'var (\nx {}\nxc C.{})\n\n'.format(gotypename, ctypename) + + # Write init_fn calls. + s +=3D '\n'.join(init_fns) + s +=3D '\n' + + # Make sure dispose_fn get's called when constructor + # returns. + if ty.dispose_fn is not None: + s +=3D 'defer C.{}(&xc)\n'.format(ty.dispose_fn) + + s +=3D '\n' + + # Call fromC to initialize Go type. + s +=3D 'if err :=3D x.fromC(&xc); err !=3D nil {\n' + s +=3D 'return nil, err }\n\n' + s +=3D 'return &x, nil}\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 746d99b5ba..b4d7dca1c6 100644 --- a/tools/golang/xenlight/helpers.gen.go +++ b/tools/golang/xenlight/helpers.gen.go @@ -30,6 +30,23 @@ typedef typeof(((struct libxl_psr_hw_info *)NULL)->u.mba= )libxl_psr_hw_info_type_ */ import "C" =20 +// NewIoportRange returns an instance of IoportRange initialized with defa= ults. +func NewIoportRange() (*IoportRange, error) { + var ( + x IoportRange + xc C.libxl_ioport_range + ) + + C.libxl_ioport_range_init(&xc) + defer C.libxl_ioport_range_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *IoportRange) fromC(xc *C.libxl_ioport_range) error { x.First =3D uint32(xc.first) x.Number =3D uint32(xc.number) @@ -50,6 +67,23 @@ func (x *IoportRange) toC(xc *C.libxl_ioport_range) (err= error) { return nil } =20 +// NewIomemRange returns an instance of IomemRange initialized with defaul= ts. +func NewIomemRange() (*IomemRange, error) { + var ( + x IomemRange + xc C.libxl_iomem_range + ) + + C.libxl_iomem_range_init(&xc) + defer C.libxl_iomem_range_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *IomemRange) fromC(xc *C.libxl_iomem_range) error { x.Start =3D uint64(xc.start) x.Number =3D uint64(xc.number) @@ -72,6 +106,23 @@ func (x *IomemRange) toC(xc *C.libxl_iomem_range) (err = error) { return nil } =20 +// NewVgaInterfaceInfo returns an instance of VgaInterfaceInfo initialized= with defaults. +func NewVgaInterfaceInfo() (*VgaInterfaceInfo, error) { + var ( + x VgaInterfaceInfo + xc C.libxl_vga_interface_info + ) + + C.libxl_vga_interface_info_init(&xc) + defer C.libxl_vga_interface_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *VgaInterfaceInfo) fromC(xc *C.libxl_vga_interface_info) error { x.Kind =3D VgaInterfaceType(xc.kind) =20 @@ -90,6 +141,23 @@ func (x *VgaInterfaceInfo) toC(xc *C.libxl_vga_interfac= e_info) (err error) { return nil } =20 +// NewVncInfo returns an instance of VncInfo initialized with defaults. +func NewVncInfo() (*VncInfo, error) { + var ( + x VncInfo + xc C.libxl_vnc_info + ) + + C.libxl_vnc_info_init(&xc) + defer C.libxl_vnc_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error { if err :=3D x.Enable.fromC(&xc.enable); err !=3D nil { return fmt.Errorf("converting field Enable: %v", err) @@ -128,6 +196,23 @@ func (x *VncInfo) toC(xc *C.libxl_vnc_info) (err error= ) { return nil } =20 +// NewSpiceInfo returns an instance of SpiceInfo initialized with defaults. +func NewSpiceInfo() (*SpiceInfo, error) { + var ( + x SpiceInfo + xc C.libxl_spice_info + ) + + C.libxl_spice_info_init(&xc) + defer C.libxl_spice_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error { if err :=3D x.Enable.fromC(&xc.enable); err !=3D nil { return fmt.Errorf("converting field Enable: %v", err) @@ -196,6 +281,23 @@ func (x *SpiceInfo) toC(xc *C.libxl_spice_info) (err e= rror) { return nil } =20 +// NewSdlInfo returns an instance of SdlInfo initialized with defaults. +func NewSdlInfo() (*SdlInfo, error) { + var ( + x SdlInfo + xc C.libxl_sdl_info + ) + + C.libxl_sdl_info_init(&xc) + defer C.libxl_sdl_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error { if err :=3D x.Enable.fromC(&xc.enable); err !=3D nil { return fmt.Errorf("converting field Enable: %v", err) @@ -232,6 +334,23 @@ func (x *SdlInfo) toC(xc *C.libxl_sdl_info) (err error= ) { return nil } =20 +// NewDominfo returns an instance of Dominfo initialized with defaults. +func NewDominfo() (*Dominfo, error) { + var ( + x Dominfo + xc C.libxl_dominfo + ) + + C.libxl_dominfo_init(&xc) + defer C.libxl_dominfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Dominfo) fromC(xc *C.libxl_dominfo) error { if err :=3D x.Uuid.fromC(&xc.uuid); err !=3D nil { return fmt.Errorf("converting field Uuid: %v", err) @@ -296,6 +415,23 @@ func (x *Dominfo) toC(xc *C.libxl_dominfo) (err error)= { return nil } =20 +// NewCpupoolinfo returns an instance of Cpupoolinfo initialized with defa= ults. +func NewCpupoolinfo() (*Cpupoolinfo, error) { + var ( + x Cpupoolinfo + xc C.libxl_cpupoolinfo + ) + + C.libxl_cpupoolinfo_init(&xc) + defer C.libxl_cpupoolinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) error { x.Poolid =3D uint32(xc.poolid) x.PoolName =3D C.GoString(xc.pool_name) @@ -328,6 +464,24 @@ func (x *Cpupoolinfo) toC(xc *C.libxl_cpupoolinfo) (er= r error) { return nil } =20 +// NewChannelinfo returns an instance of Channelinfo initialized with defa= ults. +func NewChannelinfo(connection ChannelConnection) (*Channelinfo, error) { + var ( + x Channelinfo + xc C.libxl_channelinfo + ) + + C.libxl_channelinfo_init(&xc) + C.libxl_channelinfo_init_connection(&xc, C.libxl_channel_connection(conne= ction)) + defer C.libxl_channelinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Channelinfo) fromC(xc *C.libxl_channelinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -401,6 +555,23 @@ func (x *Channelinfo) toC(xc *C.libxl_channelinfo) (er= r error) { return nil } =20 +// NewVminfo returns an instance of Vminfo initialized with defaults. +func NewVminfo() (*Vminfo, error) { + var ( + x Vminfo + xc C.libxl_vminfo + ) + + C.libxl_vminfo_init(&xc) + defer C.libxl_vminfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Vminfo) fromC(xc *C.libxl_vminfo) error { if err :=3D x.Uuid.fromC(&xc.uuid); err !=3D nil { return fmt.Errorf("converting field Uuid: %v", err) @@ -425,6 +596,23 @@ func (x *Vminfo) toC(xc *C.libxl_vminfo) (err error) { return nil } =20 +// NewVersionInfo returns an instance of VersionInfo initialized with defa= ults. +func NewVersionInfo() (*VersionInfo, error) { + var ( + x VersionInfo + xc C.libxl_version_info + ) + + C.libxl_version_info_init(&xc) + defer C.libxl_version_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -485,6 +673,23 @@ func (x *VersionInfo) toC(xc *C.libxl_version_info) (e= rr error) { return nil } =20 +// NewDomainCreateInfo returns an instance of DomainCreateInfo initialized= with defaults. +func NewDomainCreateInfo() (*DomainCreateInfo, error) { + var ( + x DomainCreateInfo + xc C.libxl_domain_create_info + ) + + C.libxl_domain_create_info_init(&xc) + defer C.libxl_domain_create_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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 { @@ -563,6 +768,23 @@ func (x *DomainCreateInfo) toC(xc *C.libxl_domain_crea= te_info) (err error) { return nil } =20 +// NewDomainRestoreParams returns an instance of DomainRestoreParams initi= alized with defaults. +func NewDomainRestoreParams() (*DomainRestoreParams, error) { + var ( + x DomainRestoreParams + xc C.libxl_domain_restore_params + ) + + C.libxl_domain_restore_params_init(&xc) + defer C.libxl_domain_restore_params_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -593,6 +815,23 @@ func (x *DomainRestoreParams) toC(xc *C.libxl_domain_r= estore_params) (err error) return nil } =20 +// NewSchedParams returns an instance of SchedParams initialized with defa= ults. +func NewSchedParams() (*SchedParams, error) { + var ( + x SchedParams + xc C.libxl_sched_params + ) + + C.libxl_sched_params_init(&xc) + defer C.libxl_sched_params_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *SchedParams) fromC(xc *C.libxl_sched_params) error { x.Vcpuid =3D int(xc.vcpuid) x.Weight =3D int(xc.weight) @@ -621,6 +860,23 @@ func (x *SchedParams) toC(xc *C.libxl_sched_params) (e= rr error) { return nil } =20 +// NewVcpuSchedParams returns an instance of VcpuSchedParams initialized w= ith defaults. +func NewVcpuSchedParams() (*VcpuSchedParams, error) { + var ( + x VcpuSchedParams + xc C.libxl_vcpu_sched_params + ) + + C.libxl_vcpu_sched_params_init(&xc) + defer C.libxl_vcpu_sched_params_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error { x.Sched =3D Scheduler(xc.sched) numVcpus :=3D int(xc.num_vcpus) @@ -657,6 +913,23 @@ func (x *VcpuSchedParams) toC(xc *C.libxl_vcpu_sched_p= arams) (err error) { return nil } =20 +// NewDomainSchedParams returns an instance of DomainSchedParams initializ= ed with defaults. +func NewDomainSchedParams() (*DomainSchedParams, error) { + var ( + x DomainSchedParams + xc C.libxl_domain_sched_params + ) + + C.libxl_domain_sched_params_init(&xc) + defer C.libxl_domain_sched_params_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error { x.Sched =3D Scheduler(xc.sched) x.Weight =3D int(xc.weight) @@ -689,6 +962,23 @@ func (x *DomainSchedParams) toC(xc *C.libxl_domain_sch= ed_params) (err error) { return nil } =20 +// NewVnodeInfo returns an instance of VnodeInfo initialized with defaults. +func NewVnodeInfo() (*VnodeInfo, error) { + var ( + x VnodeInfo + xc C.libxl_vnode_info + ) + + C.libxl_vnode_info_init(&xc) + defer C.libxl_vnode_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error { x.Memkb =3D uint64(xc.memkb) numDistances :=3D int(xc.num_distances) @@ -729,6 +1019,23 @@ func (x *VnodeInfo) toC(xc *C.libxl_vnode_info) (err = error) { return nil } =20 +// NewRdmReserve returns an instance of RdmReserve initialized with defaul= ts. +func NewRdmReserve() (*RdmReserve, error) { + var ( + x RdmReserve + xc C.libxl_rdm_reserve + ) + + C.libxl_rdm_reserve_init(&xc) + defer C.libxl_rdm_reserve_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) error { x.Strategy =3D RdmReserveStrategy(xc.strategy) x.Policy =3D RdmReservePolicy(xc.policy) @@ -749,6 +1056,24 @@ func (x *RdmReserve) toC(xc *C.libxl_rdm_reserve) (er= r error) { return nil } =20 +// NewDomainBuildInfo returns an instance of DomainBuildInfo initialized w= ith defaults. +func NewDomainBuildInfo(dtype DomainType) (*DomainBuildInfo, error) { + var ( + x DomainBuildInfo + xc C.libxl_domain_build_info + ) + + C.libxl_domain_build_info_init(&xc) + C.libxl_domain_build_info_init_type(&xc, C.libxl_domain_type(dtype)) + defer C.libxl_domain_build_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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 { @@ -878,18 +1203,18 @@ func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_b= uild_info) error { x.Tee =3D TeeType(xc.tee) x.Type =3D DomainType(xc._type) switch x.Type { - case DomainTypeHvm: - var typeHvm DomainBuildInfoTypeUnionHvm - if err :=3D typeHvm.fromC(xc); err !=3D nil { - return fmt.Errorf("converting field typeHvm: %v", err) - } - x.TypeUnion =3D typeHvm case DomainTypePv: var typePv DomainBuildInfoTypeUnionPv if err :=3D typePv.fromC(xc); err !=3D nil { return fmt.Errorf("converting field typePv: %v", err) } x.TypeUnion =3D typePv + case DomainTypeHvm: + var typeHvm DomainBuildInfoTypeUnionHvm + if err :=3D typeHvm.fromC(xc); err !=3D nil { + return fmt.Errorf("converting field typeHvm: %v", err) + } + x.TypeUnion =3D typeHvm case DomainTypePvh: var typePvh DomainBuildInfoTypeUnionPvh if err :=3D typePvh.fromC(xc); err !=3D nil { @@ -1406,6 +1731,23 @@ func (x *DomainBuildInfo) toC(xc *C.libxl_domain_bui= ld_info) (err error) { return nil } =20 +// NewDeviceVfb returns an instance of DeviceVfb initialized with defaults. +func NewDeviceVfb() (*DeviceVfb, error) { + var ( + x DeviceVfb + xc C.libxl_device_vfb + ) + + C.libxl_device_vfb_init(&xc) + defer C.libxl_device_vfb_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -1446,6 +1788,23 @@ func (x *DeviceVfb) toC(xc *C.libxl_device_vfb) (err= error) { return nil } =20 +// NewDeviceVkb returns an instance of DeviceVkb initialized with defaults. +func NewDeviceVkb() (*DeviceVkb, error) { + var ( + x DeviceVkb + xc C.libxl_device_vkb + ) + + C.libxl_device_vkb_init(&xc) + defer C.libxl_device_vkb_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -1496,6 +1855,23 @@ func (x *DeviceVkb) toC(xc *C.libxl_device_vkb) (err= error) { return nil } =20 +// NewDeviceDisk returns an instance of DeviceDisk initialized with defaul= ts. +func NewDeviceDisk() (*DeviceDisk, error) { + var ( + x DeviceDisk + xc C.libxl_device_disk + ) + + C.libxl_device_disk_init(&xc) + defer C.libxl_device_disk_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -1578,6 +1954,23 @@ func (x *DeviceDisk) toC(xc *C.libxl_device_disk) (e= rr error) { return nil } =20 +// NewDeviceNic returns an instance of DeviceNic initialized with defaults. +func NewDeviceNic() (*DeviceNic, error) { + var ( + x DeviceNic + xc C.libxl_device_nic + ) + + C.libxl_device_nic_init(&xc) + defer C.libxl_device_nic_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -1836,6 +2229,23 @@ func (x *DeviceNic) toC(xc *C.libxl_device_nic) (err= error) { return nil } =20 +// NewDevicePci returns an instance of DevicePci initialized with defaults. +func NewDevicePci() (*DevicePci, error) { + var ( + x DevicePci + xc C.libxl_device_pci + ) + + C.libxl_device_pci_init(&xc) + defer C.libxl_device_pci_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *DevicePci) fromC(xc *C.libxl_device_pci) error { x.Func =3D byte(xc._func) x.Dev =3D byte(xc.dev) @@ -1874,6 +2284,23 @@ func (x *DevicePci) toC(xc *C.libxl_device_pci) (err= error) { return nil } =20 +// NewDeviceRdm returns an instance of DeviceRdm initialized with defaults. +func NewDeviceRdm() (*DeviceRdm, error) { + var ( + x DeviceRdm + xc C.libxl_device_rdm + ) + + C.libxl_device_rdm_init(&xc) + defer C.libxl_device_rdm_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) error { x.Start =3D uint64(xc.start) x.Size =3D uint64(xc.size) @@ -1896,6 +2323,23 @@ func (x *DeviceRdm) toC(xc *C.libxl_device_rdm) (err= error) { return nil } =20 +// NewDeviceUsbctrl returns an instance of DeviceUsbctrl initialized with = defaults. +func NewDeviceUsbctrl() (*DeviceUsbctrl, error) { + var ( + x DeviceUsbctrl + xc C.libxl_device_usbctrl + ) + + C.libxl_device_usbctrl_init(&xc) + defer C.libxl_device_usbctrl_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error { x.Type =3D UsbctrlType(xc._type) x.Devid =3D Devid(xc.devid) @@ -1926,6 +2370,24 @@ func (x *DeviceUsbctrl) toC(xc *C.libxl_device_usbct= rl) (err error) { return nil } =20 +// NewDeviceUsbdev returns an instance of DeviceUsbdev initialized with de= faults. +func NewDeviceUsbdev(utype UsbdevType) (*DeviceUsbdev, error) { + var ( + x DeviceUsbdev + xc C.libxl_device_usbdev + ) + + C.libxl_device_usbdev_init(&xc) + C.libxl_device_usbdev_init_type(&xc, C.libxl_usbdev_type(utype)) + defer C.libxl_device_usbdev_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *DeviceUsbdev) fromC(xc *C.libxl_device_usbdev) error { x.Ctrl =3D Devid(xc.ctrl) x.Port =3D int(xc.port) @@ -1983,6 +2445,23 @@ func (x *DeviceUsbdev) toC(xc *C.libxl_device_usbdev= ) (err error) { return nil } =20 +// NewDeviceDtdev returns an instance of DeviceDtdev initialized with defa= ults. +func NewDeviceDtdev() (*DeviceDtdev, error) { + var ( + x DeviceDtdev + xc C.libxl_device_dtdev + ) + + C.libxl_device_dtdev_init(&xc) + defer C.libxl_device_dtdev_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *DeviceDtdev) fromC(xc *C.libxl_device_dtdev) error { x.Path =3D C.GoString(xc.path) =20 @@ -2003,6 +2482,23 @@ func (x *DeviceDtdev) toC(xc *C.libxl_device_dtdev) = (err error) { return nil } =20 +// NewDeviceVtpm returns an instance of DeviceVtpm initialized with defaul= ts. +func NewDeviceVtpm() (*DeviceVtpm, error) { + var ( + x DeviceVtpm + xc C.libxl_device_vtpm + ) + + C.libxl_device_vtpm_init(&xc) + defer C.libxl_device_vtpm_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -2033,6 +2529,23 @@ func (x *DeviceVtpm) toC(xc *C.libxl_device_vtpm) (e= rr error) { return nil } =20 +// NewDeviceP9 returns an instance of DeviceP9 initialized with defaults. +func NewDeviceP9() (*DeviceP9, error) { + var ( + x DeviceP9 + xc C.libxl_device_p9 + ) + + C.libxl_device_p9_init(&xc) + defer C.libxl_device_p9_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -2069,6 +2582,23 @@ func (x *DeviceP9) toC(xc *C.libxl_device_p9) (err e= rror) { return nil } =20 +// NewDevicePvcallsif returns an instance of DevicePvcallsif initialized w= ith defaults. +func NewDevicePvcallsif() (*DevicePvcallsif, error) { + var ( + x DevicePvcallsif + xc C.libxl_device_pvcallsif + ) + + C.libxl_device_pvcallsif_init(&xc) + defer C.libxl_device_pvcallsif_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -2093,6 +2623,24 @@ func (x *DevicePvcallsif) toC(xc *C.libxl_device_pvc= allsif) (err error) { return nil } =20 +// NewDeviceChannel returns an instance of DeviceChannel initialized with = defaults. +func NewDeviceChannel(connection ChannelConnection) (*DeviceChannel, error= ) { + var ( + x DeviceChannel + xc C.libxl_device_channel + ) + + C.libxl_device_channel_init(&xc) + C.libxl_device_channel_init_connection(&xc, C.libxl_channel_connection(co= nnection)) + defer C.libxl_device_channel_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -2158,6 +2706,23 @@ func (x *DeviceChannel) toC(xc *C.libxl_device_chann= el) (err error) { return nil } =20 +// NewConnectorParam returns an instance of ConnectorParam initialized wit= h defaults. +func NewConnectorParam() (*ConnectorParam, error) { + var ( + x ConnectorParam + xc C.libxl_connector_param + ) + + C.libxl_connector_param_init(&xc) + defer C.libxl_connector_param_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -2182,6 +2747,23 @@ func (x *ConnectorParam) toC(xc *C.libxl_connector_p= aram) (err error) { return nil } =20 +// NewDeviceVdispl returns an instance of DeviceVdispl initialized with de= faults. +func NewDeviceVdispl() (*DeviceVdispl, error) { + var ( + x DeviceVdispl + xc C.libxl_device_vdispl + ) + + C.libxl_device_vdispl_init(&xc) + defer C.libxl_device_vdispl_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -2226,6 +2808,23 @@ func (x *DeviceVdispl) toC(xc *C.libxl_device_vdispl= ) (err error) { return nil } =20 +// NewVsndParams returns an instance of VsndParams initialized with defaul= ts. +func NewVsndParams() (*VsndParams, error) { + var ( + x VsndParams + xc C.libxl_vsnd_params + ) + + C.libxl_vsnd_params_init(&xc) + defer C.libxl_vsnd_params_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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] @@ -2276,6 +2875,23 @@ func (x *VsndParams) toC(xc *C.libxl_vsnd_params) (e= rr error) { return nil } =20 +// NewVsndStream returns an instance of VsndStream initialized with defaul= ts. +func NewVsndStream() (*VsndStream, error) { + var ( + x VsndStream + xc C.libxl_vsnd_stream + ) + + C.libxl_vsnd_stream_init(&xc) + defer C.libxl_vsnd_stream_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -2304,6 +2920,23 @@ func (x *VsndStream) toC(xc *C.libxl_vsnd_stream) (e= rr error) { return nil } =20 +// NewVsndPcm returns an instance of VsndPcm initialized with defaults. +func NewVsndPcm() (*VsndPcm, error) { + var ( + x VsndPcm + xc C.libxl_vsnd_pcm + ) + + C.libxl_vsnd_pcm_init(&xc) + defer C.libxl_vsnd_pcm_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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 { @@ -2348,6 +2981,23 @@ func (x *VsndPcm) toC(xc *C.libxl_vsnd_pcm) (err err= or) { return nil } =20 +// NewDeviceVsnd returns an instance of DeviceVsnd initialized with defaul= ts. +func NewDeviceVsnd() (*DeviceVsnd, error) { + var ( + x DeviceVsnd + xc C.libxl_device_vsnd + ) + + C.libxl_device_vsnd_init(&xc) + defer C.libxl_device_vsnd_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -2404,6 +3054,23 @@ func (x *DeviceVsnd) toC(xc *C.libxl_device_vsnd) (e= rr error) { return nil } =20 +// NewDomainConfig returns an instance of DomainConfig initialized with de= faults. +func NewDomainConfig() (*DomainConfig, error) { + var ( + x DomainConfig + xc C.libxl_domain_config + ) + + C.libxl_domain_config_init(&xc) + defer C.libxl_domain_config_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error { if err :=3D x.CInfo.fromC(&xc.c_info); err !=3D nil { return fmt.Errorf("converting field CInfo: %v", err) @@ -2712,6 +3379,23 @@ func (x *DomainConfig) toC(xc *C.libxl_domain_config= ) (err error) { return nil } =20 +// NewDiskinfo returns an instance of Diskinfo initialized with defaults. +func NewDiskinfo() (*Diskinfo, error) { + var ( + x Diskinfo + xc C.libxl_diskinfo + ) + + C.libxl_diskinfo_init(&xc) + defer C.libxl_diskinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -2748,6 +3432,23 @@ func (x *Diskinfo) toC(xc *C.libxl_diskinfo) (err er= ror) { return nil } =20 +// NewNicinfo returns an instance of Nicinfo initialized with defaults. +func NewNicinfo() (*Nicinfo, error) { + var ( + x Nicinfo + xc C.libxl_nicinfo + ) + + C.libxl_nicinfo_init(&xc) + defer C.libxl_nicinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -2786,6 +3487,23 @@ func (x *Nicinfo) toC(xc *C.libxl_nicinfo) (err erro= r) { return nil } =20 +// NewVtpminfo returns an instance of Vtpminfo initialized with defaults. +func NewVtpminfo() (*Vtpminfo, error) { + var ( + x Vtpminfo + xc C.libxl_vtpminfo + ) + + C.libxl_vtpminfo_init(&xc) + defer C.libxl_vtpminfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -2828,6 +3546,23 @@ func (x *Vtpminfo) toC(xc *C.libxl_vtpminfo) (err er= ror) { return nil } =20 +// NewUsbctrlinfo returns an instance of Usbctrlinfo initialized with defa= ults. +func NewUsbctrlinfo() (*Usbctrlinfo, error) { + var ( + x Usbctrlinfo + xc C.libxl_usbctrlinfo + ) + + C.libxl_usbctrlinfo_init(&xc) + defer C.libxl_usbctrlinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo) error { x.Type =3D UsbctrlType(xc._type) x.Devid =3D Devid(xc.devid) @@ -2872,6 +3607,23 @@ func (x *Usbctrlinfo) toC(xc *C.libxl_usbctrlinfo) (= err error) { return nil } =20 +// NewVcpuinfo returns an instance of Vcpuinfo initialized with defaults. +func NewVcpuinfo() (*Vcpuinfo, error) { + var ( + x Vcpuinfo + xc C.libxl_vcpuinfo + ) + + C.libxl_vcpuinfo_init(&xc) + defer C.libxl_vcpuinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error { x.Vcpuid =3D uint32(xc.vcpuid) x.Cpu =3D uint32(xc.cpu) @@ -2912,6 +3664,23 @@ func (x *Vcpuinfo) toC(xc *C.libxl_vcpuinfo) (err er= ror) { return nil } =20 +// NewPhysinfo returns an instance of Physinfo initialized with defaults. +func NewPhysinfo() (*Physinfo, error) { + var ( + x Physinfo + xc C.libxl_physinfo + ) + + C.libxl_physinfo_init(&xc) + defer C.libxl_physinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -2972,6 +3741,23 @@ func (x *Physinfo) toC(xc *C.libxl_physinfo) (err er= ror) { return nil } =20 +// NewConnectorinfo returns an instance of Connectorinfo initialized with = defaults. +func NewConnectorinfo() (*Connectorinfo, error) { + var ( + x Connectorinfo + xc C.libxl_connectorinfo + ) + + C.libxl_connectorinfo_init(&xc) + defer C.libxl_connectorinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Connectorinfo) fromC(xc *C.libxl_connectorinfo) error { x.UniqueId =3D C.GoString(xc.unique_id) x.Width =3D uint32(xc.width) @@ -3004,6 +3790,23 @@ func (x *Connectorinfo) toC(xc *C.libxl_connectorinf= o) (err error) { return nil } =20 +// NewVdisplinfo returns an instance of Vdisplinfo initialized with defaul= ts. +func NewVdisplinfo() (*Vdisplinfo, error) { + var ( + x Vdisplinfo + xc C.libxl_vdisplinfo + ) + + C.libxl_vdisplinfo_init(&xc) + defer C.libxl_vdisplinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -3056,6 +3859,23 @@ func (x *Vdisplinfo) toC(xc *C.libxl_vdisplinfo) (er= r error) { return nil } =20 +// NewStreaminfo returns an instance of Streaminfo initialized with defaul= ts. +func NewStreaminfo() (*Streaminfo, error) { + var ( + x Streaminfo + xc C.libxl_streaminfo + ) + + C.libxl_streaminfo_init(&xc) + defer C.libxl_streaminfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error { x.ReqEvtch =3D int(xc.req_evtch) x.ReqRref =3D int(xc.req_rref) @@ -3076,6 +3896,23 @@ func (x *Streaminfo) toC(xc *C.libxl_streaminfo) (er= r error) { return nil } =20 +// NewPcminfo returns an instance of Pcminfo initialized with defaults. +func NewPcminfo() (*Pcminfo, error) { + var ( + x Pcminfo + xc C.libxl_pcminfo + ) + + C.libxl_pcminfo_init(&xc) + defer C.libxl_pcminfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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] @@ -3110,6 +3947,23 @@ func (x *Pcminfo) toC(xc *C.libxl_pcminfo) (err erro= r) { return nil } =20 +// NewVsndinfo returns an instance of Vsndinfo initialized with defaults. +func NewVsndinfo() (*Vsndinfo, error) { + var ( + x Vsndinfo + xc C.libxl_vsndinfo + ) + + C.libxl_vsndinfo_init(&xc) + defer C.libxl_vsndinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -3160,6 +4014,23 @@ func (x *Vsndinfo) toC(xc *C.libxl_vsndinfo) (err er= ror) { return nil } =20 +// NewVkbinfo returns an instance of Vkbinfo initialized with defaults. +func NewVkbinfo() (*Vkbinfo, error) { + var ( + x Vkbinfo + xc C.libxl_vkbinfo + ) + + C.libxl_vkbinfo_init(&xc) + defer C.libxl_vkbinfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error { x.Backend =3D C.GoString(xc.backend) x.BackendId =3D uint32(xc.backend_id) @@ -3196,6 +4067,23 @@ func (x *Vkbinfo) toC(xc *C.libxl_vkbinfo) (err erro= r) { return nil } =20 +// NewNumainfo returns an instance of Numainfo initialized with defaults. +func NewNumainfo() (*Numainfo, error) { + var ( + x Numainfo + xc C.libxl_numainfo + ) + + C.libxl_numainfo_init(&xc) + defer C.libxl_numainfo_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Numainfo) fromC(xc *C.libxl_numainfo) error { x.Size =3D uint64(xc.size) x.Free =3D uint64(xc.free) @@ -3230,6 +4118,23 @@ func (x *Numainfo) toC(xc *C.libxl_numainfo) (err er= ror) { return nil } =20 +// NewCputopology returns an instance of Cputopology initialized with defa= ults. +func NewCputopology() (*Cputopology, error) { + var ( + x Cputopology + xc C.libxl_cputopology + ) + + C.libxl_cputopology_init(&xc) + defer C.libxl_cputopology_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Cputopology) fromC(xc *C.libxl_cputopology) error { x.Core =3D uint32(xc.core) x.Socket =3D uint32(xc.socket) @@ -3252,6 +4157,23 @@ func (x *Cputopology) toC(xc *C.libxl_cputopology) (= err error) { return nil } =20 +// NewPcitopology returns an instance of Pcitopology initialized with defa= ults. +func NewPcitopology() (*Pcitopology, error) { + var ( + x Pcitopology + xc C.libxl_pcitopology + ) + + C.libxl_pcitopology_init(&xc) + defer C.libxl_pcitopology_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error { x.Seg =3D uint16(xc.seg) x.Bus =3D byte(xc.bus) @@ -3276,6 +4198,22 @@ func (x *Pcitopology) toC(xc *C.libxl_pcitopology) (= err error) { return nil } =20 +// NewSchedCreditParams returns an instance of SchedCreditParams initializ= ed with defaults. +func NewSchedCreditParams() (*SchedCreditParams, error) { + var ( + x SchedCreditParams + xc C.libxl_sched_credit_params + ) + + C.libxl_sched_credit_params_init(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -3292,6 +4230,22 @@ func (x *SchedCreditParams) toC(xc *C.libxl_sched_cr= edit_params) (err error) { return nil } =20 +// NewSchedCredit2Params returns an instance of SchedCredit2Params initial= ized with defaults. +func NewSchedCredit2Params() (*SchedCredit2Params, error) { + var ( + x SchedCredit2Params + xc C.libxl_sched_credit2_params + ) + + C.libxl_sched_credit2_params_init(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *SchedCredit2Params) fromC(xc *C.libxl_sched_credit2_params) error= { x.RatelimitUs =3D int(xc.ratelimit_us) =20 @@ -3304,6 +4258,23 @@ func (x *SchedCredit2Params) toC(xc *C.libxl_sched_c= redit2_params) (err error) { return nil } =20 +// NewDomainRemusInfo returns an instance of DomainRemusInfo initialized w= ith defaults. +func NewDomainRemusInfo() (*DomainRemusInfo, error) { + var ( + x DomainRemusInfo + xc C.libxl_domain_remus_info + ) + + C.libxl_domain_remus_info_init(&xc) + defer C.libxl_domain_remus_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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 { @@ -3368,6 +4339,24 @@ func (x *DomainRemusInfo) toC(xc *C.libxl_domain_rem= us_info) (err error) { return nil } =20 +// NewEvent returns an instance of Event initialized with defaults. +func NewEvent(etype EventType) (*Event, error) { + var ( + x Event + xc C.libxl_event + ) + + C.libxl_event_init(&xc) + C.libxl_event_init_type(&xc, C.libxl_event_type(etype)) + defer C.libxl_event_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *Event) fromC(xc *C.libxl_event) error { if err :=3D x.Link.fromC(&xc.link); err !=3D nil { return fmt.Errorf("converting field Link: %v", err) @@ -3379,6 +4368,12 @@ func (x *Event) fromC(xc *C.libxl_event) error { x.ForUser =3D uint64(xc.for_user) x.Type =3D EventType(xc._type) switch x.Type { + case EventTypeOperationComplete: + var typeOperationComplete EventTypeUnionOperationComplete + if err :=3D typeOperationComplete.fromC(xc); err !=3D nil { + return fmt.Errorf("converting field typeOperationComplete: %v", err) + } + x.TypeUnion =3D typeOperationComplete case EventTypeDomainShutdown: var typeDomainShutdown EventTypeUnionDomainShutdown if err :=3D typeDomainShutdown.fromC(xc); err !=3D nil { @@ -3391,12 +4386,6 @@ func (x *Event) fromC(xc *C.libxl_event) error { return fmt.Errorf("converting field typeDiskEject: %v", err) } x.TypeUnion =3D typeDiskEject - case EventTypeOperationComplete: - var typeOperationComplete EventTypeUnionOperationComplete - if err :=3D typeOperationComplete.fromC(xc); err !=3D nil { - return fmt.Errorf("converting field typeOperationComplete: %v", err) - } - x.TypeUnion =3D typeOperationComplete default: return fmt.Errorf("invalid union key '%v'", x.Type) } @@ -3493,6 +4482,23 @@ func (x *Event) toC(xc *C.libxl_event) (err error) { return nil } =20 +// NewPsrCatInfo returns an instance of PsrCatInfo initialized with defaul= ts. +func NewPsrCatInfo() (*PsrCatInfo, error) { + var ( + x PsrCatInfo + xc C.libxl_psr_cat_info + ) + + C.libxl_psr_cat_info_init(&xc) + defer C.libxl_psr_cat_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, 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) @@ -3517,22 +4523,40 @@ func (x *PsrCatInfo) toC(xc *C.libxl_psr_cat_info) = (err error) { return nil } =20 +// NewPsrHwInfo returns an instance of PsrHwInfo initialized with defaults. +func NewPsrHwInfo(ptype PsrFeatType) (*PsrHwInfo, error) { + var ( + x PsrHwInfo + xc C.libxl_psr_hw_info + ) + + C.libxl_psr_hw_info_init(&xc) + C.libxl_psr_hw_info_init_type(&xc, C.libxl_psr_feat_type(ptype)) + defer C.libxl_psr_hw_info_dispose(&xc) + + if err :=3D x.fromC(&xc); err !=3D nil { + return nil, err + } + + return &x, nil +} + func (x *PsrHwInfo) fromC(xc *C.libxl_psr_hw_info) error { x.Id =3D uint32(xc.id) x.Type =3D PsrFeatType(xc._type) switch x.Type { - case PsrFeatTypeCat: - var typeCat PsrHwInfoTypeUnionCat - if err :=3D typeCat.fromC(xc); err !=3D nil { - return fmt.Errorf("converting field typeCat: %v", err) - } - x.TypeUnion =3D typeCat case PsrFeatTypeMba: var typeMba PsrHwInfoTypeUnionMba if err :=3D typeMba.fromC(xc); err !=3D nil { return fmt.Errorf("converting field typeMba: %v", err) } x.TypeUnion =3D typeMba + case PsrFeatTypeCat: + var typeCat PsrHwInfoTypeUnionCat + if err :=3D typeCat.fromC(xc); err !=3D nil { + return fmt.Errorf("converting field typeCat: %v", err) + } + x.TypeUnion =3D typeCat default: return fmt.Errorf("invalid union key '%v'", x.Type) } --=20 2.17.1 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel