package xenlight
import (
- "errors"
- "fmt"
- "unsafe"
+"unsafe"
+"errors"
+"fmt"
)
-
/*
#cgo LDFLAGS: -lxenlight
#include <stdlib.h>
typedef typeof(((struct libxl_psr_hw_info *)NULL)->u.mba)libxl_psr_hw_info_type_union_mba;
*/
import "C"
-
// NewIoportRange returns an instance of IoportRange initialized with defaults.
func NewIoportRange() (*IoportRange, error) {
- var (
- x IoportRange
- xc C.libxl_ioport_range
- )
+var (
+x IoportRange
+xc C.libxl_ioport_range)
- C.libxl_ioport_range_init(&xc)
- defer C.libxl_ioport_range_dispose(&xc)
+C.libxl_ioport_range_init(&xc)
+defer C.libxl_ioport_range_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *IoportRange) fromC(xc *C.libxl_ioport_range) error {
- x.First = uint32(xc.first)
- x.Number = uint32(xc.number)
+ x.First = uint32(xc.first)
+x.Number = uint32(xc.number)
- return nil
-}
+ return nil}
-func (x *IoportRange) toC(xc *C.libxl_ioport_range) (err error) {
- defer func() {
- if err != nil {
- C.libxl_ioport_range_dispose(xc)
- }
- }()
+func (x *IoportRange) toC(xc *C.libxl_ioport_range) (err error){defer func(){
+if err != nil{
+C.libxl_ioport_range_dispose(xc)}
+}()
- xc.first = C.uint32_t(x.First)
- xc.number = C.uint32_t(x.Number)
+xc.first = C.uint32_t(x.First)
+xc.number = C.uint32_t(x.Number)
- return nil
-}
+ return nil
+ }
// NewIomemRange returns an instance of IomemRange initialized with defaults.
func NewIomemRange() (*IomemRange, error) {
- var (
- x IomemRange
- xc C.libxl_iomem_range
- )
+var (
+x IomemRange
+xc C.libxl_iomem_range)
- C.libxl_iomem_range_init(&xc)
- defer C.libxl_iomem_range_dispose(&xc)
+C.libxl_iomem_range_init(&xc)
+defer C.libxl_iomem_range_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *IomemRange) fromC(xc *C.libxl_iomem_range) error {
- x.Start = uint64(xc.start)
- x.Number = uint64(xc.number)
- x.Gfn = uint64(xc.gfn)
+ x.Start = uint64(xc.start)
+x.Number = uint64(xc.number)
+x.Gfn = uint64(xc.gfn)
- return nil
-}
+ return nil}
-func (x *IomemRange) toC(xc *C.libxl_iomem_range) (err error) {
- defer func() {
- if err != nil {
- C.libxl_iomem_range_dispose(xc)
- }
- }()
+func (x *IomemRange) toC(xc *C.libxl_iomem_range) (err error){defer func(){
+if err != nil{
+C.libxl_iomem_range_dispose(xc)}
+}()
- xc.start = C.uint64_t(x.Start)
- xc.number = C.uint64_t(x.Number)
- xc.gfn = C.uint64_t(x.Gfn)
+xc.start = C.uint64_t(x.Start)
+xc.number = C.uint64_t(x.Number)
+xc.gfn = C.uint64_t(x.Gfn)
- return nil
-}
+ return nil
+ }
// NewVgaInterfaceInfo returns an instance of VgaInterfaceInfo initialized with defaults.
func NewVgaInterfaceInfo() (*VgaInterfaceInfo, error) {
- var (
- x VgaInterfaceInfo
- xc C.libxl_vga_interface_info
- )
+var (
+x VgaInterfaceInfo
+xc C.libxl_vga_interface_info)
- C.libxl_vga_interface_info_init(&xc)
- defer C.libxl_vga_interface_info_dispose(&xc)
+C.libxl_vga_interface_info_init(&xc)
+defer C.libxl_vga_interface_info_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *VgaInterfaceInfo) fromC(xc *C.libxl_vga_interface_info) error {
- x.Kind = VgaInterfaceType(xc.kind)
+ x.Kind = VgaInterfaceType(xc.kind)
- return nil
-}
+ return nil}
-func (x *VgaInterfaceInfo) toC(xc *C.libxl_vga_interface_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vga_interface_info_dispose(xc)
- }
- }()
+func (x *VgaInterfaceInfo) toC(xc *C.libxl_vga_interface_info) (err error){defer func(){
+if err != nil{
+C.libxl_vga_interface_info_dispose(xc)}
+}()
- xc.kind = C.libxl_vga_interface_type(x.Kind)
+xc.kind = C.libxl_vga_interface_type(x.Kind)
- return nil
-}
+ return nil
+ }
// NewVncInfo returns an instance of VncInfo initialized with defaults.
func NewVncInfo() (*VncInfo, error) {
- var (
- x VncInfo
- xc C.libxl_vnc_info
- )
+var (
+x VncInfo
+xc C.libxl_vnc_info)
- C.libxl_vnc_info_init(&xc)
- defer C.libxl_vnc_info_dispose(&xc)
+C.libxl_vnc_info_init(&xc)
+defer C.libxl_vnc_info_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error {
- if err := x.Enable.fromC(&xc.enable); err != nil {
- return fmt.Errorf("converting field Enable: %v", err)
- }
- x.Listen = C.GoString(xc.listen)
- x.Passwd = C.GoString(xc.passwd)
- x.Display = int(xc.display)
- if err := x.Findunused.fromC(&xc.findunused); err != nil {
- return fmt.Errorf("converting field Findunused: %v", err)
- }
-
- return nil
-}
-
-func (x *VncInfo) toC(xc *C.libxl_vnc_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vnc_info_dispose(xc)
- }
- }()
-
- if err := x.Enable.toC(&xc.enable); err != nil {
- return fmt.Errorf("converting field Enable: %v", err)
- }
- if x.Listen != "" {
- xc.listen = C.CString(x.Listen)
- }
- if x.Passwd != "" {
- xc.passwd = C.CString(x.Passwd)
- }
- xc.display = C.int(x.Display)
- if err := x.Findunused.toC(&xc.findunused); err != nil {
- return fmt.Errorf("converting field Findunused: %v", err)
- }
-
- return nil
+ if err := x.Enable.fromC(&xc.enable);err != nil {
+return fmt.Errorf("converting field Enable: %v", err)
+}
+x.Listen = C.GoString(xc.listen)
+x.Passwd = C.GoString(xc.passwd)
+x.Display = int(xc.display)
+if err := x.Findunused.fromC(&xc.findunused);err != nil {
+return fmt.Errorf("converting field Findunused: %v", err)
}
+ return nil}
+
+func (x *VncInfo) toC(xc *C.libxl_vnc_info) (err error){defer func(){
+if err != nil{
+C.libxl_vnc_info_dispose(xc)}
+}()
+
+if err := x.Enable.toC(&xc.enable); err != nil {
+return fmt.Errorf("converting field Enable: %v", err)
+}
+if x.Listen != "" {
+xc.listen = C.CString(x.Listen)}
+if x.Passwd != "" {
+xc.passwd = C.CString(x.Passwd)}
+xc.display = C.int(x.Display)
+if err := x.Findunused.toC(&xc.findunused); err != nil {
+return fmt.Errorf("converting field Findunused: %v", err)
+}
+
+ return nil
+ }
+
// NewSpiceInfo returns an instance of SpiceInfo initialized with defaults.
func NewSpiceInfo() (*SpiceInfo, error) {
- var (
- x SpiceInfo
- xc C.libxl_spice_info
- )
+var (
+x SpiceInfo
+xc C.libxl_spice_info)
- C.libxl_spice_info_init(&xc)
- defer C.libxl_spice_info_dispose(&xc)
+C.libxl_spice_info_init(&xc)
+defer C.libxl_spice_info_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error {
- if err := x.Enable.fromC(&xc.enable); err != nil {
- return fmt.Errorf("converting field Enable: %v", err)
- }
- x.Port = int(xc.port)
- x.TlsPort = int(xc.tls_port)
- x.Host = C.GoString(xc.host)
- if err := x.DisableTicketing.fromC(&xc.disable_ticketing); err != nil {
- return fmt.Errorf("converting field DisableTicketing: %v", err)
- }
- x.Passwd = C.GoString(xc.passwd)
- if err := x.AgentMouse.fromC(&xc.agent_mouse); err != nil {
- return fmt.Errorf("converting field AgentMouse: %v", err)
- }
- if err := x.Vdagent.fromC(&xc.vdagent); err != nil {
- return fmt.Errorf("converting field Vdagent: %v", err)
- }
- if err := x.ClipboardSharing.fromC(&xc.clipboard_sharing); err != nil {
- return fmt.Errorf("converting field ClipboardSharing: %v", err)
- }
- x.Usbredirection = int(xc.usbredirection)
- x.ImageCompression = C.GoString(xc.image_compression)
- x.StreamingVideo = C.GoString(xc.streaming_video)
-
- return nil
-}
-
-func (x *SpiceInfo) toC(xc *C.libxl_spice_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_spice_info_dispose(xc)
- }
- }()
-
- if err := x.Enable.toC(&xc.enable); err != nil {
- return fmt.Errorf("converting field Enable: %v", err)
- }
- xc.port = C.int(x.Port)
- xc.tls_port = C.int(x.TlsPort)
- if x.Host != "" {
- xc.host = C.CString(x.Host)
- }
- if err := x.DisableTicketing.toC(&xc.disable_ticketing); err != nil {
- return fmt.Errorf("converting field DisableTicketing: %v", err)
- }
- if x.Passwd != "" {
- xc.passwd = C.CString(x.Passwd)
- }
- if err := x.AgentMouse.toC(&xc.agent_mouse); err != nil {
- return fmt.Errorf("converting field AgentMouse: %v", err)
- }
- if err := x.Vdagent.toC(&xc.vdagent); err != nil {
- return fmt.Errorf("converting field Vdagent: %v", err)
- }
- if err := x.ClipboardSharing.toC(&xc.clipboard_sharing); err != nil {
- return fmt.Errorf("converting field ClipboardSharing: %v", err)
- }
- xc.usbredirection = C.int(x.Usbredirection)
- if x.ImageCompression != "" {
- xc.image_compression = C.CString(x.ImageCompression)
- }
- if x.StreamingVideo != "" {
- xc.streaming_video = C.CString(x.StreamingVideo)
- }
-
- return nil
+ if err := x.Enable.fromC(&xc.enable);err != nil {
+return fmt.Errorf("converting field Enable: %v", err)
+}
+x.Port = int(xc.port)
+x.TlsPort = int(xc.tls_port)
+x.Host = C.GoString(xc.host)
+if err := x.DisableTicketing.fromC(&xc.disable_ticketing);err != nil {
+return fmt.Errorf("converting field DisableTicketing: %v", err)
+}
+x.Passwd = C.GoString(xc.passwd)
+if err := x.AgentMouse.fromC(&xc.agent_mouse);err != nil {
+return fmt.Errorf("converting field AgentMouse: %v", err)
+}
+if err := x.Vdagent.fromC(&xc.vdagent);err != nil {
+return fmt.Errorf("converting field Vdagent: %v", err)
+}
+if err := x.ClipboardSharing.fromC(&xc.clipboard_sharing);err != nil {
+return fmt.Errorf("converting field ClipboardSharing: %v", err)
+}
+x.Usbredirection = int(xc.usbredirection)
+x.ImageCompression = C.GoString(xc.image_compression)
+x.StreamingVideo = C.GoString(xc.streaming_video)
+
+ return nil}
+
+func (x *SpiceInfo) toC(xc *C.libxl_spice_info) (err error){defer func(){
+if err != nil{
+C.libxl_spice_info_dispose(xc)}
+}()
+
+if err := x.Enable.toC(&xc.enable); err != nil {
+return fmt.Errorf("converting field Enable: %v", err)
+}
+xc.port = C.int(x.Port)
+xc.tls_port = C.int(x.TlsPort)
+if x.Host != "" {
+xc.host = C.CString(x.Host)}
+if err := x.DisableTicketing.toC(&xc.disable_ticketing); err != nil {
+return fmt.Errorf("converting field DisableTicketing: %v", err)
+}
+if x.Passwd != "" {
+xc.passwd = C.CString(x.Passwd)}
+if err := x.AgentMouse.toC(&xc.agent_mouse); err != nil {
+return fmt.Errorf("converting field AgentMouse: %v", err)
+}
+if err := x.Vdagent.toC(&xc.vdagent); err != nil {
+return fmt.Errorf("converting field Vdagent: %v", err)
+}
+if err := x.ClipboardSharing.toC(&xc.clipboard_sharing); err != nil {
+return fmt.Errorf("converting field ClipboardSharing: %v", err)
}
+xc.usbredirection = C.int(x.Usbredirection)
+if x.ImageCompression != "" {
+xc.image_compression = C.CString(x.ImageCompression)}
+if x.StreamingVideo != "" {
+xc.streaming_video = C.CString(x.StreamingVideo)}
+
+ return nil
+ }
// NewSdlInfo returns an instance of SdlInfo initialized with defaults.
func NewSdlInfo() (*SdlInfo, error) {
- var (
- x SdlInfo
- xc C.libxl_sdl_info
- )
+var (
+x SdlInfo
+xc C.libxl_sdl_info)
- C.libxl_sdl_info_init(&xc)
- defer C.libxl_sdl_info_dispose(&xc)
+C.libxl_sdl_info_init(&xc)
+defer C.libxl_sdl_info_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error {
- if err := x.Enable.fromC(&xc.enable); err != nil {
- return fmt.Errorf("converting field Enable: %v", err)
- }
- if err := x.Opengl.fromC(&xc.opengl); err != nil {
- return fmt.Errorf("converting field Opengl: %v", err)
- }
- x.Display = C.GoString(xc.display)
- x.Xauthority = C.GoString(xc.xauthority)
-
- return nil
-}
-
-func (x *SdlInfo) toC(xc *C.libxl_sdl_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_sdl_info_dispose(xc)
- }
- }()
-
- if err := x.Enable.toC(&xc.enable); err != nil {
- return fmt.Errorf("converting field Enable: %v", err)
- }
- if err := x.Opengl.toC(&xc.opengl); err != nil {
- return fmt.Errorf("converting field Opengl: %v", err)
- }
- if x.Display != "" {
- xc.display = C.CString(x.Display)
- }
- if x.Xauthority != "" {
- xc.xauthority = C.CString(x.Xauthority)
- }
-
- return nil
+ if err := x.Enable.fromC(&xc.enable);err != nil {
+return fmt.Errorf("converting field Enable: %v", err)
+}
+if err := x.Opengl.fromC(&xc.opengl);err != nil {
+return fmt.Errorf("converting field Opengl: %v", err)
}
+x.Display = C.GoString(xc.display)
+x.Xauthority = C.GoString(xc.xauthority)
+
+ return nil}
+
+func (x *SdlInfo) toC(xc *C.libxl_sdl_info) (err error){defer func(){
+if err != nil{
+C.libxl_sdl_info_dispose(xc)}
+}()
+
+if err := x.Enable.toC(&xc.enable); err != nil {
+return fmt.Errorf("converting field Enable: %v", err)
+}
+if err := x.Opengl.toC(&xc.opengl); err != nil {
+return fmt.Errorf("converting field Opengl: %v", err)
+}
+if x.Display != "" {
+xc.display = C.CString(x.Display)}
+if x.Xauthority != "" {
+xc.xauthority = C.CString(x.Xauthority)}
+
+ return nil
+ }
// NewDominfo returns an instance of Dominfo initialized with defaults.
func NewDominfo() (*Dominfo, error) {
- var (
- x Dominfo
- xc C.libxl_dominfo
- )
+var (
+x Dominfo
+xc C.libxl_dominfo)
- C.libxl_dominfo_init(&xc)
- defer C.libxl_dominfo_dispose(&xc)
+C.libxl_dominfo_init(&xc)
+defer C.libxl_dominfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Dominfo) fromC(xc *C.libxl_dominfo) error {
- if err := x.Uuid.fromC(&xc.uuid); err != nil {
- return fmt.Errorf("converting field Uuid: %v", err)
- }
- x.Domid = Domid(xc.domid)
- x.Ssidref = uint32(xc.ssidref)
- x.SsidLabel = C.GoString(xc.ssid_label)
- x.Running = bool(xc.running)
- x.Blocked = bool(xc.blocked)
- x.Paused = bool(xc.paused)
- x.Shutdown = bool(xc.shutdown)
- x.Dying = bool(xc.dying)
- x.NeverStop = bool(xc.never_stop)
- x.ShutdownReason = ShutdownReason(xc.shutdown_reason)
- x.OutstandingMemkb = uint64(xc.outstanding_memkb)
- x.CurrentMemkb = uint64(xc.current_memkb)
- x.SharedMemkb = uint64(xc.shared_memkb)
- x.PagedMemkb = uint64(xc.paged_memkb)
- x.MaxMemkb = uint64(xc.max_memkb)
- x.CpuTime = uint64(xc.cpu_time)
- x.VcpuMaxId = uint32(xc.vcpu_max_id)
- x.VcpuOnline = uint32(xc.vcpu_online)
- x.Cpupool = uint32(xc.cpupool)
- x.DomainType = DomainType(xc.domain_type)
-
- return nil
-}
-
-func (x *Dominfo) toC(xc *C.libxl_dominfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_dominfo_dispose(xc)
- }
- }()
-
- if err := x.Uuid.toC(&xc.uuid); err != nil {
- return fmt.Errorf("converting field Uuid: %v", err)
- }
- xc.domid = C.libxl_domid(x.Domid)
- xc.ssidref = C.uint32_t(x.Ssidref)
- if x.SsidLabel != "" {
- xc.ssid_label = C.CString(x.SsidLabel)
- }
- xc.running = C.bool(x.Running)
- xc.blocked = C.bool(x.Blocked)
- xc.paused = C.bool(x.Paused)
- xc.shutdown = C.bool(x.Shutdown)
- xc.dying = C.bool(x.Dying)
- xc.never_stop = C.bool(x.NeverStop)
- xc.shutdown_reason = C.libxl_shutdown_reason(x.ShutdownReason)
- xc.outstanding_memkb = C.uint64_t(x.OutstandingMemkb)
- xc.current_memkb = C.uint64_t(x.CurrentMemkb)
- xc.shared_memkb = C.uint64_t(x.SharedMemkb)
- xc.paged_memkb = C.uint64_t(x.PagedMemkb)
- xc.max_memkb = C.uint64_t(x.MaxMemkb)
- xc.cpu_time = C.uint64_t(x.CpuTime)
- xc.vcpu_max_id = C.uint32_t(x.VcpuMaxId)
- xc.vcpu_online = C.uint32_t(x.VcpuOnline)
- xc.cpupool = C.uint32_t(x.Cpupool)
- xc.domain_type = C.libxl_domain_type(x.DomainType)
-
- return nil
-}
+ if err := x.Uuid.fromC(&xc.uuid);err != nil {
+return fmt.Errorf("converting field Uuid: %v", err)
+}
+x.Domid = Domid(xc.domid)
+x.Ssidref = uint32(xc.ssidref)
+x.SsidLabel = C.GoString(xc.ssid_label)
+x.Running = bool(xc.running)
+x.Blocked = bool(xc.blocked)
+x.Paused = bool(xc.paused)
+x.Shutdown = bool(xc.shutdown)
+x.Dying = bool(xc.dying)
+x.NeverStop = bool(xc.never_stop)
+x.ShutdownReason = ShutdownReason(xc.shutdown_reason)
+x.OutstandingMemkb = uint64(xc.outstanding_memkb)
+x.CurrentMemkb = uint64(xc.current_memkb)
+x.SharedMemkb = uint64(xc.shared_memkb)
+x.PagedMemkb = uint64(xc.paged_memkb)
+x.MaxMemkb = uint64(xc.max_memkb)
+x.CpuTime = uint64(xc.cpu_time)
+x.VcpuMaxId = uint32(xc.vcpu_max_id)
+x.VcpuOnline = uint32(xc.vcpu_online)
+x.Cpupool = uint32(xc.cpupool)
+x.DomainType = DomainType(xc.domain_type)
+
+ return nil}
+
+func (x *Dominfo) toC(xc *C.libxl_dominfo) (err error){defer func(){
+if err != nil{
+C.libxl_dominfo_dispose(xc)}
+}()
+
+if err := x.Uuid.toC(&xc.uuid); err != nil {
+return fmt.Errorf("converting field Uuid: %v", err)
+}
+xc.domid = C.libxl_domid(x.Domid)
+xc.ssidref = C.uint32_t(x.Ssidref)
+if x.SsidLabel != "" {
+xc.ssid_label = C.CString(x.SsidLabel)}
+xc.running = C.bool(x.Running)
+xc.blocked = C.bool(x.Blocked)
+xc.paused = C.bool(x.Paused)
+xc.shutdown = C.bool(x.Shutdown)
+xc.dying = C.bool(x.Dying)
+xc.never_stop = C.bool(x.NeverStop)
+xc.shutdown_reason = C.libxl_shutdown_reason(x.ShutdownReason)
+xc.outstanding_memkb = C.uint64_t(x.OutstandingMemkb)
+xc.current_memkb = C.uint64_t(x.CurrentMemkb)
+xc.shared_memkb = C.uint64_t(x.SharedMemkb)
+xc.paged_memkb = C.uint64_t(x.PagedMemkb)
+xc.max_memkb = C.uint64_t(x.MaxMemkb)
+xc.cpu_time = C.uint64_t(x.CpuTime)
+xc.vcpu_max_id = C.uint32_t(x.VcpuMaxId)
+xc.vcpu_online = C.uint32_t(x.VcpuOnline)
+xc.cpupool = C.uint32_t(x.Cpupool)
+xc.domain_type = C.libxl_domain_type(x.DomainType)
+
+ return nil
+ }
// NewCpupoolinfo returns an instance of Cpupoolinfo initialized with defaults.
func NewCpupoolinfo() (*Cpupoolinfo, error) {
- var (
- x Cpupoolinfo
- xc C.libxl_cpupoolinfo
- )
+var (
+x Cpupoolinfo
+xc C.libxl_cpupoolinfo)
- C.libxl_cpupoolinfo_init(&xc)
- defer C.libxl_cpupoolinfo_dispose(&xc)
+C.libxl_cpupoolinfo_init(&xc)
+defer C.libxl_cpupoolinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) error {
- x.Poolid = uint32(xc.poolid)
- x.PoolName = C.GoString(xc.pool_name)
- x.Sched = Scheduler(xc.sched)
- x.NDom = uint32(xc.n_dom)
- if err := x.Cpumap.fromC(&xc.cpumap); err != nil {
- return fmt.Errorf("converting field Cpumap: %v", err)
- }
-
- return nil
+ x.Poolid = uint32(xc.poolid)
+x.PoolName = C.GoString(xc.pool_name)
+x.Sched = Scheduler(xc.sched)
+x.NDom = uint32(xc.n_dom)
+if err := x.Cpumap.fromC(&xc.cpumap);err != nil {
+return fmt.Errorf("converting field Cpumap: %v", err)
}
-func (x *Cpupoolinfo) toC(xc *C.libxl_cpupoolinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_cpupoolinfo_dispose(xc)
- }
- }()
+ return nil}
- xc.poolid = C.uint32_t(x.Poolid)
- if x.PoolName != "" {
- xc.pool_name = C.CString(x.PoolName)
- }
- xc.sched = C.libxl_scheduler(x.Sched)
- xc.n_dom = C.uint32_t(x.NDom)
- if err := x.Cpumap.toC(&xc.cpumap); err != nil {
- return fmt.Errorf("converting field Cpumap: %v", err)
- }
+func (x *Cpupoolinfo) toC(xc *C.libxl_cpupoolinfo) (err error){defer func(){
+if err != nil{
+C.libxl_cpupoolinfo_dispose(xc)}
+}()
- return nil
+xc.poolid = C.uint32_t(x.Poolid)
+if x.PoolName != "" {
+xc.pool_name = C.CString(x.PoolName)}
+xc.sched = C.libxl_scheduler(x.Sched)
+xc.n_dom = C.uint32_t(x.NDom)
+if err := x.Cpumap.toC(&xc.cpumap); err != nil {
+return fmt.Errorf("converting field Cpumap: %v", err)
}
+ return nil
+ }
+
// NewChannelinfo returns an instance of Channelinfo initialized with defaults.
func NewChannelinfo(connection ChannelConnection) (*Channelinfo, error) {
- var (
- x Channelinfo
- xc C.libxl_channelinfo
- )
+var (
+x Channelinfo
+xc C.libxl_channelinfo)
- C.libxl_channelinfo_init(&xc)
- C.libxl_channelinfo_init_connection(&xc, C.libxl_channel_connection(connection))
- defer C.libxl_channelinfo_dispose(&xc)
+C.libxl_channelinfo_init(&xc)
+C.libxl_channelinfo_init_connection(&xc, C.libxl_channel_connection(connection))
+defer C.libxl_channelinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Channelinfo) fromC(xc *C.libxl_channelinfo) error {
- x.Backend = C.GoString(xc.backend)
- x.BackendId = uint32(xc.backend_id)
- x.Frontend = C.GoString(xc.frontend)
- x.FrontendId = uint32(xc.frontend_id)
- x.Devid = Devid(xc.devid)
- x.State = int(xc.state)
- x.Evtch = int(xc.evtch)
- x.Rref = int(xc.rref)
- x.Connection = ChannelConnection(xc.connection)
- switch x.Connection {
- case ChannelConnectionUnknown:
- x.ConnectionUnion = nil
- case ChannelConnectionPty:
- var connectionPty ChannelinfoConnectionUnionPty
- if err := connectionPty.fromC(xc); err != nil {
- return fmt.Errorf("converting field connectionPty: %v", err)
- }
- x.ConnectionUnion = connectionPty
- case ChannelConnectionSocket:
- x.ConnectionUnion = nil
- default:
- return fmt.Errorf("invalid union key '%v'", x.Connection)
- }
-
- return nil
-}
+ x.Backend = C.GoString(xc.backend)
+x.BackendId = uint32(xc.backend_id)
+x.Frontend = C.GoString(xc.frontend)
+x.FrontendId = uint32(xc.frontend_id)
+x.Devid = Devid(xc.devid)
+x.State = int(xc.state)
+x.Evtch = int(xc.evtch)
+x.Rref = int(xc.rref)
+x.Connection = ChannelConnection(xc.connection)
+switch x.Connection{
+case ChannelConnectionUnknown:
+x.ConnectionUnion = nil
+case ChannelConnectionPty:
+var connectionPty ChannelinfoConnectionUnionPty
+if err := connectionPty.fromC(xc);err != nil {
+ return fmt.Errorf("converting field connectionPty: %v", err)
+}
+x.ConnectionUnion = connectionPty
+case ChannelConnectionSocket:
+x.ConnectionUnion = nil
+default:
+return fmt.Errorf("invalid union key '%v'", x.Connection)}
+
+ return nil}
func (x *ChannelinfoConnectionUnionPty) fromC(xc *C.libxl_channelinfo) error {
- if ChannelConnection(xc.connection) != ChannelConnectionPty {
- return errors.New("expected union key ChannelConnectionPty")
- }
-
- tmp := (*C.libxl_channelinfo_connection_union_pty)(unsafe.Pointer(&xc.u[0]))
- x.Path = C.GoString(tmp.path)
- return nil
-}
-
-func (x *Channelinfo) toC(xc *C.libxl_channelinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_channelinfo_dispose(xc)
- }
- }()
-
- if x.Backend != "" {
- xc.backend = C.CString(x.Backend)
- }
- xc.backend_id = C.uint32_t(x.BackendId)
- if x.Frontend != "" {
- xc.frontend = C.CString(x.Frontend)
- }
- xc.frontend_id = C.uint32_t(x.FrontendId)
- xc.devid = C.libxl_devid(x.Devid)
- xc.state = C.int(x.State)
- xc.evtch = C.int(x.Evtch)
- xc.rref = C.int(x.Rref)
- xc.connection = C.libxl_channel_connection(x.Connection)
- switch x.Connection {
- case ChannelConnectionUnknown:
- break
- case ChannelConnectionPty:
- tmp, ok := x.ConnectionUnion.(ChannelinfoConnectionUnionPty)
- if !ok {
- return errors.New("wrong type for union key connection")
- }
- var pty C.libxl_channelinfo_connection_union_pty
- if tmp.Path != "" {
- pty.path = C.CString(tmp.Path)
- }
- ptyBytes := C.GoBytes(unsafe.Pointer(&pty), C.sizeof_libxl_channelinfo_connection_union_pty)
- copy(xc.u[:], ptyBytes)
- case ChannelConnectionSocket:
- break
- default:
- return fmt.Errorf("invalid union key '%v'", x.Connection)
- }
-
- return nil
-}
+if ChannelConnection(xc.connection) != ChannelConnectionPty {
+return errors.New("expected union key ChannelConnectionPty")
+}
+
+tmp := (*C.libxl_channelinfo_connection_union_pty)(unsafe.Pointer(&xc.u[0]))
+x.Path = C.GoString(tmp.path)
+return nil
+}
+
+func (x *Channelinfo) toC(xc *C.libxl_channelinfo) (err error){defer func(){
+if err != nil{
+C.libxl_channelinfo_dispose(xc)}
+}()
+
+if x.Backend != "" {
+xc.backend = C.CString(x.Backend)}
+xc.backend_id = C.uint32_t(x.BackendId)
+if x.Frontend != "" {
+xc.frontend = C.CString(x.Frontend)}
+xc.frontend_id = C.uint32_t(x.FrontendId)
+xc.devid = C.libxl_devid(x.Devid)
+xc.state = C.int(x.State)
+xc.evtch = C.int(x.Evtch)
+xc.rref = C.int(x.Rref)
+xc.connection = C.libxl_channel_connection(x.Connection)
+switch x.Connection{
+case ChannelConnectionUnknown:
+break
+case ChannelConnectionPty:
+tmp, ok := x.ConnectionUnion.(ChannelinfoConnectionUnionPty)
+if !ok {
+return errors.New("wrong type for union key connection")
+}
+var pty C.libxl_channelinfo_connection_union_pty
+if tmp.Path != "" {
+pty.path = C.CString(tmp.Path)}
+ptyBytes := C.GoBytes(unsafe.Pointer(&pty),C.sizeof_libxl_channelinfo_connection_union_pty)
+copy(xc.u[:],ptyBytes)
+case ChannelConnectionSocket:
+break
+default:
+return fmt.Errorf("invalid union key '%v'", x.Connection)}
+
+ return nil
+ }
// NewVminfo returns an instance of Vminfo initialized with defaults.
func NewVminfo() (*Vminfo, error) {
- var (
- x Vminfo
- xc C.libxl_vminfo
- )
+var (
+x Vminfo
+xc C.libxl_vminfo)
- C.libxl_vminfo_init(&xc)
- defer C.libxl_vminfo_dispose(&xc)
+C.libxl_vminfo_init(&xc)
+defer C.libxl_vminfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Vminfo) fromC(xc *C.libxl_vminfo) error {
- if err := x.Uuid.fromC(&xc.uuid); err != nil {
- return fmt.Errorf("converting field Uuid: %v", err)
- }
- x.Domid = Domid(xc.domid)
-
- return nil
+ if err := x.Uuid.fromC(&xc.uuid);err != nil {
+return fmt.Errorf("converting field Uuid: %v", err)
}
+x.Domid = Domid(xc.domid)
-func (x *Vminfo) toC(xc *C.libxl_vminfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vminfo_dispose(xc)
- }
- }()
+ return nil}
- if err := x.Uuid.toC(&xc.uuid); err != nil {
- return fmt.Errorf("converting field Uuid: %v", err)
- }
- xc.domid = C.libxl_domid(x.Domid)
+func (x *Vminfo) toC(xc *C.libxl_vminfo) (err error){defer func(){
+if err != nil{
+C.libxl_vminfo_dispose(xc)}
+}()
- return nil
+if err := x.Uuid.toC(&xc.uuid); err != nil {
+return fmt.Errorf("converting field Uuid: %v", err)
}
+xc.domid = C.libxl_domid(x.Domid)
+
+ return nil
+ }
// NewVersionInfo returns an instance of VersionInfo initialized with defaults.
func NewVersionInfo() (*VersionInfo, error) {
- var (
- x VersionInfo
- xc C.libxl_version_info
- )
+var (
+x VersionInfo
+xc C.libxl_version_info)
- C.libxl_version_info_init(&xc)
- defer C.libxl_version_info_dispose(&xc)
+C.libxl_version_info_init(&xc)
+defer C.libxl_version_info_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *VersionInfo) fromC(xc *C.libxl_version_info) error {
- x.XenVersionMajor = int(xc.xen_version_major)
- x.XenVersionMinor = int(xc.xen_version_minor)
- x.XenVersionExtra = C.GoString(xc.xen_version_extra)
- x.Compiler = C.GoString(xc.compiler)
- x.CompileBy = C.GoString(xc.compile_by)
- x.CompileDomain = C.GoString(xc.compile_domain)
- x.CompileDate = C.GoString(xc.compile_date)
- x.Capabilities = C.GoString(xc.capabilities)
- x.Changeset = C.GoString(xc.changeset)
- x.VirtStart = uint64(xc.virt_start)
- x.Pagesize = int(xc.pagesize)
- x.Commandline = C.GoString(xc.commandline)
- x.BuildId = C.GoString(xc.build_id)
-
- return nil
-}
-
-func (x *VersionInfo) toC(xc *C.libxl_version_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_version_info_dispose(xc)
- }
- }()
-
- xc.xen_version_major = C.int(x.XenVersionMajor)
- xc.xen_version_minor = C.int(x.XenVersionMinor)
- if x.XenVersionExtra != "" {
- xc.xen_version_extra = C.CString(x.XenVersionExtra)
- }
- if x.Compiler != "" {
- xc.compiler = C.CString(x.Compiler)
- }
- if x.CompileBy != "" {
- xc.compile_by = C.CString(x.CompileBy)
- }
- if x.CompileDomain != "" {
- xc.compile_domain = C.CString(x.CompileDomain)
- }
- if x.CompileDate != "" {
- xc.compile_date = C.CString(x.CompileDate)
- }
- if x.Capabilities != "" {
- xc.capabilities = C.CString(x.Capabilities)
- }
- if x.Changeset != "" {
- xc.changeset = C.CString(x.Changeset)
- }
- xc.virt_start = C.uint64_t(x.VirtStart)
- xc.pagesize = C.int(x.Pagesize)
- if x.Commandline != "" {
- xc.commandline = C.CString(x.Commandline)
- }
- if x.BuildId != "" {
- xc.build_id = C.CString(x.BuildId)
- }
-
- return nil
-}
+ x.XenVersionMajor = int(xc.xen_version_major)
+x.XenVersionMinor = int(xc.xen_version_minor)
+x.XenVersionExtra = C.GoString(xc.xen_version_extra)
+x.Compiler = C.GoString(xc.compiler)
+x.CompileBy = C.GoString(xc.compile_by)
+x.CompileDomain = C.GoString(xc.compile_domain)
+x.CompileDate = C.GoString(xc.compile_date)
+x.Capabilities = C.GoString(xc.capabilities)
+x.Changeset = C.GoString(xc.changeset)
+x.VirtStart = uint64(xc.virt_start)
+x.Pagesize = int(xc.pagesize)
+x.Commandline = C.GoString(xc.commandline)
+x.BuildId = C.GoString(xc.build_id)
+
+ return nil}
+
+func (x *VersionInfo) toC(xc *C.libxl_version_info) (err error){defer func(){
+if err != nil{
+C.libxl_version_info_dispose(xc)}
+}()
+
+xc.xen_version_major = C.int(x.XenVersionMajor)
+xc.xen_version_minor = C.int(x.XenVersionMinor)
+if x.XenVersionExtra != "" {
+xc.xen_version_extra = C.CString(x.XenVersionExtra)}
+if x.Compiler != "" {
+xc.compiler = C.CString(x.Compiler)}
+if x.CompileBy != "" {
+xc.compile_by = C.CString(x.CompileBy)}
+if x.CompileDomain != "" {
+xc.compile_domain = C.CString(x.CompileDomain)}
+if x.CompileDate != "" {
+xc.compile_date = C.CString(x.CompileDate)}
+if x.Capabilities != "" {
+xc.capabilities = C.CString(x.Capabilities)}
+if x.Changeset != "" {
+xc.changeset = C.CString(x.Changeset)}
+xc.virt_start = C.uint64_t(x.VirtStart)
+xc.pagesize = C.int(x.Pagesize)
+if x.Commandline != "" {
+xc.commandline = C.CString(x.Commandline)}
+if x.BuildId != "" {
+xc.build_id = C.CString(x.BuildId)}
+
+ return nil
+ }
// NewDomainCreateInfo returns an instance of DomainCreateInfo initialized with defaults.
func NewDomainCreateInfo() (*DomainCreateInfo, error) {
- var (
- x DomainCreateInfo
- xc C.libxl_domain_create_info
- )
+var (
+x DomainCreateInfo
+xc C.libxl_domain_create_info)
- C.libxl_domain_create_info_init(&xc)
- defer C.libxl_domain_create_info_dispose(&xc)
+C.libxl_domain_create_info_init(&xc)
+defer C.libxl_domain_create_info_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DomainCreateInfo) fromC(xc *C.libxl_domain_create_info) error {
- x.Type = DomainType(xc._type)
- if err := x.Hap.fromC(&xc.hap); err != nil {
- return fmt.Errorf("converting field Hap: %v", err)
- }
- if err := x.Oos.fromC(&xc.oos); err != nil {
- return fmt.Errorf("converting field Oos: %v", err)
- }
- x.Ssidref = uint32(xc.ssidref)
- x.SsidLabel = C.GoString(xc.ssid_label)
- x.Name = C.GoString(xc.name)
- x.Domid = Domid(xc.domid)
- if err := x.Uuid.fromC(&xc.uuid); err != nil {
- return fmt.Errorf("converting field Uuid: %v", err)
- }
- if err := x.Xsdata.fromC(&xc.xsdata); err != nil {
- return fmt.Errorf("converting field Xsdata: %v", err)
- }
- if err := x.Platformdata.fromC(&xc.platformdata); err != nil {
- return fmt.Errorf("converting field Platformdata: %v", err)
- }
- x.Poolid = uint32(xc.poolid)
- x.PoolName = C.GoString(xc.pool_name)
- if err := x.RunHotplugScripts.fromC(&xc.run_hotplug_scripts); err != nil {
- return fmt.Errorf("converting field RunHotplugScripts: %v", err)
- }
- if err := x.DriverDomain.fromC(&xc.driver_domain); err != nil {
- return fmt.Errorf("converting field DriverDomain: %v", err)
- }
- x.Passthrough = Passthrough(xc.passthrough)
- if err := x.XendSuspendEvtchnCompat.fromC(&xc.xend_suspend_evtchn_compat); err != nil {
- return fmt.Errorf("converting field XendSuspendEvtchnCompat: %v", err)
- }
-
- return nil
-}
-
-func (x *DomainCreateInfo) toC(xc *C.libxl_domain_create_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_domain_create_info_dispose(xc)
- }
- }()
-
- xc._type = C.libxl_domain_type(x.Type)
- if err := x.Hap.toC(&xc.hap); err != nil {
- return fmt.Errorf("converting field Hap: %v", err)
- }
- if err := x.Oos.toC(&xc.oos); err != nil {
- return fmt.Errorf("converting field Oos: %v", err)
- }
- xc.ssidref = C.uint32_t(x.Ssidref)
- if x.SsidLabel != "" {
- xc.ssid_label = C.CString(x.SsidLabel)
- }
- if x.Name != "" {
- xc.name = C.CString(x.Name)
- }
- xc.domid = C.libxl_domid(x.Domid)
- if err := x.Uuid.toC(&xc.uuid); err != nil {
- return fmt.Errorf("converting field Uuid: %v", err)
- }
- if err := x.Xsdata.toC(&xc.xsdata); err != nil {
- return fmt.Errorf("converting field Xsdata: %v", err)
- }
- if err := x.Platformdata.toC(&xc.platformdata); err != nil {
- return fmt.Errorf("converting field Platformdata: %v", err)
- }
- xc.poolid = C.uint32_t(x.Poolid)
- if x.PoolName != "" {
- xc.pool_name = C.CString(x.PoolName)
- }
- if err := x.RunHotplugScripts.toC(&xc.run_hotplug_scripts); err != nil {
- return fmt.Errorf("converting field RunHotplugScripts: %v", err)
- }
- if err := x.DriverDomain.toC(&xc.driver_domain); err != nil {
- return fmt.Errorf("converting field DriverDomain: %v", err)
- }
- xc.passthrough = C.libxl_passthrough(x.Passthrough)
- if err := x.XendSuspendEvtchnCompat.toC(&xc.xend_suspend_evtchn_compat); err != nil {
- return fmt.Errorf("converting field XendSuspendEvtchnCompat: %v", err)
- }
-
- return nil
+ x.Type = DomainType(xc._type)
+if err := x.Hap.fromC(&xc.hap);err != nil {
+return fmt.Errorf("converting field Hap: %v", err)
+}
+if err := x.Oos.fromC(&xc.oos);err != nil {
+return fmt.Errorf("converting field Oos: %v", err)
+}
+x.Ssidref = uint32(xc.ssidref)
+x.SsidLabel = C.GoString(xc.ssid_label)
+x.Name = C.GoString(xc.name)
+x.Domid = Domid(xc.domid)
+if err := x.Uuid.fromC(&xc.uuid);err != nil {
+return fmt.Errorf("converting field Uuid: %v", err)
}
+if err := x.Xsdata.fromC(&xc.xsdata);err != nil {
+return fmt.Errorf("converting field Xsdata: %v", err)
+}
+if err := x.Platformdata.fromC(&xc.platformdata);err != nil {
+return fmt.Errorf("converting field Platformdata: %v", err)
+}
+x.Poolid = uint32(xc.poolid)
+x.PoolName = C.GoString(xc.pool_name)
+if err := x.RunHotplugScripts.fromC(&xc.run_hotplug_scripts);err != nil {
+return fmt.Errorf("converting field RunHotplugScripts: %v", err)
+}
+if err := x.DriverDomain.fromC(&xc.driver_domain);err != nil {
+return fmt.Errorf("converting field DriverDomain: %v", err)
+}
+x.Passthrough = Passthrough(xc.passthrough)
+if err := x.XendSuspendEvtchnCompat.fromC(&xc.xend_suspend_evtchn_compat);err != nil {
+return fmt.Errorf("converting field XendSuspendEvtchnCompat: %v", err)
+}
+
+ return nil}
+
+func (x *DomainCreateInfo) toC(xc *C.libxl_domain_create_info) (err error){defer func(){
+if err != nil{
+C.libxl_domain_create_info_dispose(xc)}
+}()
+
+xc._type = C.libxl_domain_type(x.Type)
+if err := x.Hap.toC(&xc.hap); err != nil {
+return fmt.Errorf("converting field Hap: %v", err)
+}
+if err := x.Oos.toC(&xc.oos); err != nil {
+return fmt.Errorf("converting field Oos: %v", err)
+}
+xc.ssidref = C.uint32_t(x.Ssidref)
+if x.SsidLabel != "" {
+xc.ssid_label = C.CString(x.SsidLabel)}
+if x.Name != "" {
+xc.name = C.CString(x.Name)}
+xc.domid = C.libxl_domid(x.Domid)
+if err := x.Uuid.toC(&xc.uuid); err != nil {
+return fmt.Errorf("converting field Uuid: %v", err)
+}
+if err := x.Xsdata.toC(&xc.xsdata); err != nil {
+return fmt.Errorf("converting field Xsdata: %v", err)
+}
+if err := x.Platformdata.toC(&xc.platformdata); err != nil {
+return fmt.Errorf("converting field Platformdata: %v", err)
+}
+xc.poolid = C.uint32_t(x.Poolid)
+if x.PoolName != "" {
+xc.pool_name = C.CString(x.PoolName)}
+if err := x.RunHotplugScripts.toC(&xc.run_hotplug_scripts); err != nil {
+return fmt.Errorf("converting field RunHotplugScripts: %v", err)
+}
+if err := x.DriverDomain.toC(&xc.driver_domain); err != nil {
+return fmt.Errorf("converting field DriverDomain: %v", err)
+}
+xc.passthrough = C.libxl_passthrough(x.Passthrough)
+if err := x.XendSuspendEvtchnCompat.toC(&xc.xend_suspend_evtchn_compat); err != nil {
+return fmt.Errorf("converting field XendSuspendEvtchnCompat: %v", err)
+}
+
+ return nil
+ }
// NewDomainRestoreParams returns an instance of DomainRestoreParams initialized with defaults.
func NewDomainRestoreParams() (*DomainRestoreParams, error) {
- var (
- x DomainRestoreParams
- xc C.libxl_domain_restore_params
- )
+var (
+x DomainRestoreParams
+xc C.libxl_domain_restore_params)
- C.libxl_domain_restore_params_init(&xc)
- defer C.libxl_domain_restore_params_dispose(&xc)
+C.libxl_domain_restore_params_init(&xc)
+defer C.libxl_domain_restore_params_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DomainRestoreParams) fromC(xc *C.libxl_domain_restore_params) error {
- x.CheckpointedStream = int(xc.checkpointed_stream)
- x.StreamVersion = uint32(xc.stream_version)
- x.ColoProxyScript = C.GoString(xc.colo_proxy_script)
- if err := x.UserspaceColoProxy.fromC(&xc.userspace_colo_proxy); err != nil {
- return fmt.Errorf("converting field UserspaceColoProxy: %v", err)
- }
-
- return nil
+ x.CheckpointedStream = int(xc.checkpointed_stream)
+x.StreamVersion = uint32(xc.stream_version)
+x.ColoProxyScript = C.GoString(xc.colo_proxy_script)
+if err := x.UserspaceColoProxy.fromC(&xc.userspace_colo_proxy);err != nil {
+return fmt.Errorf("converting field UserspaceColoProxy: %v", err)
}
-func (x *DomainRestoreParams) toC(xc *C.libxl_domain_restore_params) (err error) {
- defer func() {
- if err != nil {
- C.libxl_domain_restore_params_dispose(xc)
- }
- }()
+ return nil}
- xc.checkpointed_stream = C.int(x.CheckpointedStream)
- xc.stream_version = C.uint32_t(x.StreamVersion)
- if x.ColoProxyScript != "" {
- xc.colo_proxy_script = C.CString(x.ColoProxyScript)
- }
- if err := x.UserspaceColoProxy.toC(&xc.userspace_colo_proxy); err != nil {
- return fmt.Errorf("converting field UserspaceColoProxy: %v", err)
- }
+func (x *DomainRestoreParams) toC(xc *C.libxl_domain_restore_params) (err error){defer func(){
+if err != nil{
+C.libxl_domain_restore_params_dispose(xc)}
+}()
- return nil
+xc.checkpointed_stream = C.int(x.CheckpointedStream)
+xc.stream_version = C.uint32_t(x.StreamVersion)
+if x.ColoProxyScript != "" {
+xc.colo_proxy_script = C.CString(x.ColoProxyScript)}
+if err := x.UserspaceColoProxy.toC(&xc.userspace_colo_proxy); err != nil {
+return fmt.Errorf("converting field UserspaceColoProxy: %v", err)
}
+ return nil
+ }
+
// NewSchedParams returns an instance of SchedParams initialized with defaults.
func NewSchedParams() (*SchedParams, error) {
- var (
- x SchedParams
- xc C.libxl_sched_params
- )
+var (
+x SchedParams
+xc C.libxl_sched_params)
- C.libxl_sched_params_init(&xc)
- defer C.libxl_sched_params_dispose(&xc)
+C.libxl_sched_params_init(&xc)
+defer C.libxl_sched_params_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *SchedParams) fromC(xc *C.libxl_sched_params) error {
- x.Vcpuid = int(xc.vcpuid)
- x.Weight = int(xc.weight)
- x.Cap = int(xc.cap)
- x.Period = int(xc.period)
- x.Extratime = int(xc.extratime)
- x.Budget = int(xc.budget)
+ x.Vcpuid = int(xc.vcpuid)
+x.Weight = int(xc.weight)
+x.Cap = int(xc.cap)
+x.Period = int(xc.period)
+x.Extratime = int(xc.extratime)
+x.Budget = int(xc.budget)
+
+ return nil}
+
+func (x *SchedParams) toC(xc *C.libxl_sched_params) (err error){defer func(){
+if err != nil{
+C.libxl_sched_params_dispose(xc)}
+}()
+
+xc.vcpuid = C.int(x.Vcpuid)
+xc.weight = C.int(x.Weight)
+xc.cap = C.int(x.Cap)
+xc.period = C.int(x.Period)
+xc.extratime = C.int(x.Extratime)
+xc.budget = C.int(x.Budget)
+
+ return nil
+ }
- return nil
-}
+// NewVcpuSchedParams returns an instance of VcpuSchedParams initialized with defaults.
+func NewVcpuSchedParams() (*VcpuSchedParams, error) {
+var (
+x VcpuSchedParams
+xc C.libxl_vcpu_sched_params)
-func (x *SchedParams) toC(xc *C.libxl_sched_params) (err error) {
- defer func() {
- if err != nil {
- C.libxl_sched_params_dispose(xc)
- }
- }()
+C.libxl_vcpu_sched_params_init(&xc)
+defer C.libxl_vcpu_sched_params_dispose(&xc)
- xc.vcpuid = C.int(x.Vcpuid)
- xc.weight = C.int(x.Weight)
- xc.cap = C.int(x.Cap)
- xc.period = C.int(x.Period)
- xc.extratime = C.int(x.Extratime)
- xc.budget = C.int(x.Budget)
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return nil
-}
+return &x, nil}
-// NewVcpuSchedParams returns an instance of VcpuSchedParams initialized with defaults.
-func NewVcpuSchedParams() (*VcpuSchedParams, error) {
- var (
- x VcpuSchedParams
- xc C.libxl_vcpu_sched_params
- )
+func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
+ x.Sched = Scheduler(xc.sched)
+x.Vcpus = nil
+if n := int(xc.num_vcpus); n > 0 {
+cVcpus := (*[1<<28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:n:n]
+x.Vcpus = make([]SchedParams, n)
+for i, v := range cVcpus {
+if err := x.Vcpus[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Vcpus: %v", err) }
+}
+}
- C.libxl_vcpu_sched_params_init(&xc)
- defer C.libxl_vcpu_sched_params_dispose(&xc)
+ return nil}
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+func (x *VcpuSchedParams) toC(xc *C.libxl_vcpu_sched_params) (err error){defer func(){
+if err != nil{
+C.libxl_vcpu_sched_params_dispose(xc)}
+}()
- return &x, nil
+xc.sched = C.libxl_scheduler(x.Sched)
+if numVcpus := len(x.Vcpus); numVcpus > 0 {
+xc.vcpus = (*C.libxl_sched_params)(C.malloc(C.ulong(numVcpus)*C.sizeof_libxl_sched_params))
+xc.num_vcpus = C.int(numVcpus)
+cVcpus := (*[1<<28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:numVcpus:numVcpus]
+for i,v := range x.Vcpus {
+if err := v.toC(&cVcpus[i]); err != nil {
+return fmt.Errorf("converting field Vcpus: %v", err)
+}
}
-
-func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
- x.Sched = Scheduler(xc.sched)
- x.Vcpus = nil
- if n := int(xc.num_vcpus); n > 0 {
- cVcpus := (*[1 << 28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:n:n]
- x.Vcpus = make([]SchedParams, n)
- for i, v := range cVcpus {
- if err := x.Vcpus[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Vcpus: %v", err)
- }
- }
- }
-
- return nil
-}
-
-func (x *VcpuSchedParams) toC(xc *C.libxl_vcpu_sched_params) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vcpu_sched_params_dispose(xc)
- }
- }()
-
- xc.sched = C.libxl_scheduler(x.Sched)
- if numVcpus := len(x.Vcpus); numVcpus > 0 {
- xc.vcpus = (*C.libxl_sched_params)(C.malloc(C.ulong(numVcpus) * C.sizeof_libxl_sched_params))
- xc.num_vcpus = C.int(numVcpus)
- cVcpus := (*[1 << 28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:numVcpus:numVcpus]
- for i, v := range x.Vcpus {
- if err := v.toC(&cVcpus[i]); err != nil {
- return fmt.Errorf("converting field Vcpus: %v", err)
- }
- }
- }
-
- return nil
}
+ return nil
+ }
+
// NewDomainSchedParams returns an instance of DomainSchedParams initialized with defaults.
func NewDomainSchedParams() (*DomainSchedParams, error) {
- var (
- x DomainSchedParams
- xc C.libxl_domain_sched_params
- )
+var (
+x DomainSchedParams
+xc C.libxl_domain_sched_params)
- C.libxl_domain_sched_params_init(&xc)
- defer C.libxl_domain_sched_params_dispose(&xc)
+C.libxl_domain_sched_params_init(&xc)
+defer C.libxl_domain_sched_params_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error {
- x.Sched = Scheduler(xc.sched)
- x.Weight = int(xc.weight)
- x.Cap = int(xc.cap)
- x.Period = int(xc.period)
- x.Budget = int(xc.budget)
- x.Extratime = int(xc.extratime)
- x.Slice = int(xc.slice)
- x.Latency = int(xc.latency)
+ x.Sched = Scheduler(xc.sched)
+x.Weight = int(xc.weight)
+x.Cap = int(xc.cap)
+x.Period = int(xc.period)
+x.Budget = int(xc.budget)
+x.Extratime = int(xc.extratime)
+x.Slice = int(xc.slice)
+x.Latency = int(xc.latency)
+
+ return nil}
+
+func (x *DomainSchedParams) toC(xc *C.libxl_domain_sched_params) (err error){defer func(){
+if err != nil{
+C.libxl_domain_sched_params_dispose(xc)}
+}()
+
+xc.sched = C.libxl_scheduler(x.Sched)
+xc.weight = C.int(x.Weight)
+xc.cap = C.int(x.Cap)
+xc.period = C.int(x.Period)
+xc.budget = C.int(x.Budget)
+xc.extratime = C.int(x.Extratime)
+xc.slice = C.int(x.Slice)
+xc.latency = C.int(x.Latency)
+
+ return nil
+ }
- return nil
-}
+// NewVnodeInfo returns an instance of VnodeInfo initialized with defaults.
+func NewVnodeInfo() (*VnodeInfo, error) {
+var (
+x VnodeInfo
+xc C.libxl_vnode_info)
-func (x *DomainSchedParams) toC(xc *C.libxl_domain_sched_params) (err error) {
- defer func() {
- if err != nil {
- C.libxl_domain_sched_params_dispose(xc)
- }
- }()
+C.libxl_vnode_info_init(&xc)
+defer C.libxl_vnode_info_dispose(&xc)
- xc.sched = C.libxl_scheduler(x.Sched)
- xc.weight = C.int(x.Weight)
- xc.cap = C.int(x.Cap)
- xc.period = C.int(x.Period)
- xc.budget = C.int(x.Budget)
- xc.extratime = C.int(x.Extratime)
- xc.slice = C.int(x.Slice)
- xc.latency = C.int(x.Latency)
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return nil
-}
+return &x, nil}
-// NewVnodeInfo returns an instance of VnodeInfo initialized with defaults.
-func NewVnodeInfo() (*VnodeInfo, error) {
- var (
- x VnodeInfo
- xc C.libxl_vnode_info
- )
+func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error {
+ x.Memkb = uint64(xc.memkb)
+x.Distances = nil
+if n := int(xc.num_distances); n > 0 {
+cDistances := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.distances))[:n:n]
+x.Distances = make([]uint32, n)
+for i, v := range cDistances {
+x.Distances[i] = uint32(v)
+}
+}
+x.Pnode = uint32(xc.pnode)
+if err := x.Vcpus.fromC(&xc.vcpus);err != nil {
+return fmt.Errorf("converting field Vcpus: %v", err)
+}
- C.libxl_vnode_info_init(&xc)
- defer C.libxl_vnode_info_dispose(&xc)
+ return nil}
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+func (x *VnodeInfo) toC(xc *C.libxl_vnode_info) (err error){defer func(){
+if err != nil{
+C.libxl_vnode_info_dispose(xc)}
+}()
- return &x, nil
+xc.memkb = C.uint64_t(x.Memkb)
+if numDistances := len(x.Distances); numDistances > 0 {
+xc.distances = (*C.uint32_t)(C.malloc(C.size_t(numDistances*numDistances)))
+xc.num_distances = C.int(numDistances)
+cDistances := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.distances))[:numDistances:numDistances]
+for i,v := range x.Distances {
+cDistances[i] = C.uint32_t(v)
}
-
-func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error {
- x.Memkb = uint64(xc.memkb)
- x.Distances = nil
- if n := int(xc.num_distances); n > 0 {
- cDistances := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.distances))[:n:n]
- x.Distances = make([]uint32, n)
- for i, v := range cDistances {
- x.Distances[i] = uint32(v)
- }
- }
- x.Pnode = uint32(xc.pnode)
- if err := x.Vcpus.fromC(&xc.vcpus); err != nil {
- return fmt.Errorf("converting field Vcpus: %v", err)
- }
-
- return nil
-}
-
-func (x *VnodeInfo) toC(xc *C.libxl_vnode_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vnode_info_dispose(xc)
- }
- }()
-
- xc.memkb = C.uint64_t(x.Memkb)
- if numDistances := len(x.Distances); numDistances > 0 {
- xc.distances = (*C.uint32_t)(C.malloc(C.size_t(numDistances * numDistances)))
- xc.num_distances = C.int(numDistances)
- cDistances := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.distances))[:numDistances:numDistances]
- for i, v := range x.Distances {
- cDistances[i] = C.uint32_t(v)
- }
- }
- xc.pnode = C.uint32_t(x.Pnode)
- if err := x.Vcpus.toC(&xc.vcpus); err != nil {
- return fmt.Errorf("converting field Vcpus: %v", err)
- }
-
- return nil
}
+xc.pnode = C.uint32_t(x.Pnode)
+if err := x.Vcpus.toC(&xc.vcpus); err != nil {
+return fmt.Errorf("converting field Vcpus: %v", err)
+}
+
+ return nil
+ }
// NewRdmReserve returns an instance of RdmReserve initialized with defaults.
func NewRdmReserve() (*RdmReserve, error) {
- var (
- x RdmReserve
- xc C.libxl_rdm_reserve
- )
+var (
+x RdmReserve
+xc C.libxl_rdm_reserve)
- C.libxl_rdm_reserve_init(&xc)
- defer C.libxl_rdm_reserve_dispose(&xc)
+C.libxl_rdm_reserve_init(&xc)
+defer C.libxl_rdm_reserve_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) error {
- x.Strategy = RdmReserveStrategy(xc.strategy)
- x.Policy = RdmReservePolicy(xc.policy)
+ x.Strategy = RdmReserveStrategy(xc.strategy)
+x.Policy = RdmReservePolicy(xc.policy)
- return nil
-}
+ return nil}
-func (x *RdmReserve) toC(xc *C.libxl_rdm_reserve) (err error) {
- defer func() {
- if err != nil {
- C.libxl_rdm_reserve_dispose(xc)
- }
- }()
+func (x *RdmReserve) toC(xc *C.libxl_rdm_reserve) (err error){defer func(){
+if err != nil{
+C.libxl_rdm_reserve_dispose(xc)}
+}()
- xc.strategy = C.libxl_rdm_reserve_strategy(x.Strategy)
- xc.policy = C.libxl_rdm_reserve_policy(x.Policy)
+xc.strategy = C.libxl_rdm_reserve_strategy(x.Strategy)
+xc.policy = C.libxl_rdm_reserve_policy(x.Policy)
- return nil
-}
+ return nil
+ }
// NewDomainBuildInfo returns an instance of DomainBuildInfo initialized with defaults.
func NewDomainBuildInfo(dtype DomainType) (*DomainBuildInfo, error) {
- var (
- x DomainBuildInfo
- xc C.libxl_domain_build_info
- )
+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)
+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 := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error {
- x.MaxVcpus = int(xc.max_vcpus)
- if err := x.AvailVcpus.fromC(&xc.avail_vcpus); err != nil {
- return fmt.Errorf("converting field AvailVcpus: %v", err)
- }
- if err := x.Cpumap.fromC(&xc.cpumap); err != nil {
- return fmt.Errorf("converting field Cpumap: %v", err)
- }
- if err := x.Nodemap.fromC(&xc.nodemap); err != nil {
- return fmt.Errorf("converting field Nodemap: %v", err)
- }
- x.VcpuHardAffinity = nil
- if n := int(xc.num_vcpu_hard_affinity); n > 0 {
- cVcpuHardAffinity := (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_hard_affinity))[:n:n]
- x.VcpuHardAffinity = make([]Bitmap, n)
- for i, v := range cVcpuHardAffinity {
- if err := x.VcpuHardAffinity[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field VcpuHardAffinity: %v", err)
- }
- }
- }
- x.VcpuSoftAffinity = nil
- if n := int(xc.num_vcpu_soft_affinity); n > 0 {
- cVcpuSoftAffinity := (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_soft_affinity))[:n:n]
- x.VcpuSoftAffinity = make([]Bitmap, n)
- for i, v := range cVcpuSoftAffinity {
- if err := x.VcpuSoftAffinity[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field VcpuSoftAffinity: %v", err)
- }
- }
- }
- if err := x.NumaPlacement.fromC(&xc.numa_placement); err != nil {
- return fmt.Errorf("converting field NumaPlacement: %v", err)
- }
- x.TscMode = TscMode(xc.tsc_mode)
- x.MaxMemkb = uint64(xc.max_memkb)
- x.TargetMemkb = uint64(xc.target_memkb)
- x.VideoMemkb = uint64(xc.video_memkb)
- x.ShadowMemkb = uint64(xc.shadow_memkb)
- x.IommuMemkb = uint64(xc.iommu_memkb)
- x.RtcTimeoffset = uint32(xc.rtc_timeoffset)
- x.ExecSsidref = uint32(xc.exec_ssidref)
- x.ExecSsidLabel = C.GoString(xc.exec_ssid_label)
- if err := x.Localtime.fromC(&xc.localtime); err != nil {
- return fmt.Errorf("converting field Localtime: %v", err)
- }
- if err := x.DisableMigrate.fromC(&xc.disable_migrate); err != nil {
- return fmt.Errorf("converting field DisableMigrate: %v", err)
- }
- if err := x.Cpuid.fromC(&xc.cpuid); err != nil {
- return fmt.Errorf("converting field Cpuid: %v", err)
- }
- x.BlkdevStart = C.GoString(xc.blkdev_start)
- x.VnumaNodes = nil
- if n := int(xc.num_vnuma_nodes); n > 0 {
- cVnumaNodes := (*[1 << 28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_nodes))[:n:n]
- x.VnumaNodes = make([]VnodeInfo, n)
- for i, v := range cVnumaNodes {
- if err := x.VnumaNodes[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field VnumaNodes: %v", err)
- }
- }
- }
- x.MaxGrantFrames = uint32(xc.max_grant_frames)
- x.MaxMaptrackFrames = uint32(xc.max_maptrack_frames)
- x.DeviceModelVersion = DeviceModelVersion(xc.device_model_version)
- if err := x.DeviceModelStubdomain.fromC(&xc.device_model_stubdomain); err != nil {
- return fmt.Errorf("converting field DeviceModelStubdomain: %v", err)
- }
- x.StubdomainMemkb = uint64(xc.stubdomain_memkb)
- x.StubdomainKernel = C.GoString(xc.stubdomain_kernel)
- x.StubdomainRamdisk = C.GoString(xc.stubdomain_ramdisk)
- x.DeviceModel = C.GoString(xc.device_model)
- x.DeviceModelSsidref = uint32(xc.device_model_ssidref)
- x.DeviceModelSsidLabel = C.GoString(xc.device_model_ssid_label)
- x.DeviceModelUser = C.GoString(xc.device_model_user)
- if err := x.Extra.fromC(&xc.extra); err != nil {
- return fmt.Errorf("converting field Extra: %v", err)
- }
- if err := x.ExtraPv.fromC(&xc.extra_pv); err != nil {
- return fmt.Errorf("converting field ExtraPv: %v", err)
- }
- if err := x.ExtraHvm.fromC(&xc.extra_hvm); err != nil {
- return fmt.Errorf("converting field ExtraHvm: %v", err)
- }
- if err := x.SchedParams.fromC(&xc.sched_params); err != nil {
- return fmt.Errorf("converting field SchedParams: %v", err)
- }
- x.Ioports = nil
- if n := int(xc.num_ioports); n > 0 {
- cIoports := (*[1 << 28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports))[:n:n]
- x.Ioports = make([]IoportRange, n)
- for i, v := range cIoports {
- if err := x.Ioports[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Ioports: %v", err)
- }
- }
- }
- x.Irqs = nil
- if n := int(xc.num_irqs); n > 0 {
- cIrqs := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:n:n]
- x.Irqs = make([]uint32, n)
- for i, v := range cIrqs {
- x.Irqs[i] = uint32(v)
- }
- }
- x.Iomem = nil
- if n := int(xc.num_iomem); n > 0 {
- cIomem := (*[1 << 28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:n:n]
- x.Iomem = make([]IomemRange, n)
- for i, v := range cIomem {
- if err := x.Iomem[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Iomem: %v", err)
- }
- }
- }
- if err := x.ClaimMode.fromC(&xc.claim_mode); err != nil {
- return fmt.Errorf("converting field ClaimMode: %v", err)
- }
- x.EventChannels = uint32(xc.event_channels)
- x.Kernel = C.GoString(xc.kernel)
- x.Cmdline = C.GoString(xc.cmdline)
- x.Ramdisk = C.GoString(xc.ramdisk)
- x.DeviceTree = C.GoString(xc.device_tree)
- if err := x.Acpi.fromC(&xc.acpi); err != nil {
- return fmt.Errorf("converting field Acpi: %v", err)
- }
- x.Bootloader = C.GoString(xc.bootloader)
- if err := x.BootloaderArgs.fromC(&xc.bootloader_args); err != nil {
- return fmt.Errorf("converting field BootloaderArgs: %v", err)
- }
- x.TimerMode = TimerMode(xc.timer_mode)
- if err := x.NestedHvm.fromC(&xc.nested_hvm); err != nil {
- return fmt.Errorf("converting field NestedHvm: %v", err)
- }
- if err := x.Apic.fromC(&xc.apic); err != nil {
- return fmt.Errorf("converting field Apic: %v", err)
- }
- if err := x.DmRestrict.fromC(&xc.dm_restrict); err != nil {
- return fmt.Errorf("converting field DmRestrict: %v", err)
- }
- x.Tee = TeeType(xc.tee)
- x.Type = DomainType(xc._type)
- switch x.Type {
- case DomainTypeHvm:
- var typeHvm DomainBuildInfoTypeUnionHvm
- if err := typeHvm.fromC(xc); err != nil {
- return fmt.Errorf("converting field typeHvm: %v", err)
- }
- x.TypeUnion = typeHvm
- case DomainTypePv:
- var typePv DomainBuildInfoTypeUnionPv
- if err := typePv.fromC(xc); err != nil {
- return fmt.Errorf("converting field typePv: %v", err)
- }
- x.TypeUnion = typePv
- case DomainTypePvh:
- var typePvh DomainBuildInfoTypeUnionPvh
- if err := typePvh.fromC(xc); err != nil {
- return fmt.Errorf("converting field typePvh: %v", err)
- }
- x.TypeUnion = typePvh
- case DomainTypeInvalid:
- x.TypeUnion = nil
- default:
- return fmt.Errorf("invalid union key '%v'", x.Type)
- }
- x.ArchArm.GicVersion = GicVersion(xc.arch_arm.gic_version)
- x.ArchArm.Vuart = VuartType(xc.arch_arm.vuart)
- x.Altp2M = Altp2MMode(xc.altp2m)
-
- return nil
-}
+ x.MaxVcpus = int(xc.max_vcpus)
+if err := x.AvailVcpus.fromC(&xc.avail_vcpus);err != nil {
+return fmt.Errorf("converting field AvailVcpus: %v", err)
+}
+if err := x.Cpumap.fromC(&xc.cpumap);err != nil {
+return fmt.Errorf("converting field Cpumap: %v", err)
+}
+if err := x.Nodemap.fromC(&xc.nodemap);err != nil {
+return fmt.Errorf("converting field Nodemap: %v", err)
+}
+x.VcpuHardAffinity = nil
+if n := int(xc.num_vcpu_hard_affinity); n > 0 {
+cVcpuHardAffinity := (*[1<<28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_hard_affinity))[:n:n]
+x.VcpuHardAffinity = make([]Bitmap, n)
+for i, v := range cVcpuHardAffinity {
+if err := x.VcpuHardAffinity[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field VcpuHardAffinity: %v", err) }
+}
+}
+x.VcpuSoftAffinity = nil
+if n := int(xc.num_vcpu_soft_affinity); n > 0 {
+cVcpuSoftAffinity := (*[1<<28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_soft_affinity))[:n:n]
+x.VcpuSoftAffinity = make([]Bitmap, n)
+for i, v := range cVcpuSoftAffinity {
+if err := x.VcpuSoftAffinity[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field VcpuSoftAffinity: %v", err) }
+}
+}
+if err := x.NumaPlacement.fromC(&xc.numa_placement);err != nil {
+return fmt.Errorf("converting field NumaPlacement: %v", err)
+}
+x.TscMode = TscMode(xc.tsc_mode)
+x.MaxMemkb = uint64(xc.max_memkb)
+x.TargetMemkb = uint64(xc.target_memkb)
+x.VideoMemkb = uint64(xc.video_memkb)
+x.ShadowMemkb = uint64(xc.shadow_memkb)
+x.IommuMemkb = uint64(xc.iommu_memkb)
+x.RtcTimeoffset = uint32(xc.rtc_timeoffset)
+x.ExecSsidref = uint32(xc.exec_ssidref)
+x.ExecSsidLabel = C.GoString(xc.exec_ssid_label)
+if err := x.Localtime.fromC(&xc.localtime);err != nil {
+return fmt.Errorf("converting field Localtime: %v", err)
+}
+if err := x.DisableMigrate.fromC(&xc.disable_migrate);err != nil {
+return fmt.Errorf("converting field DisableMigrate: %v", err)
+}
+if err := x.Cpuid.fromC(&xc.cpuid);err != nil {
+return fmt.Errorf("converting field Cpuid: %v", err)
+}
+x.BlkdevStart = C.GoString(xc.blkdev_start)
+x.VnumaNodes = nil
+if n := int(xc.num_vnuma_nodes); n > 0 {
+cVnumaNodes := (*[1<<28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_nodes))[:n:n]
+x.VnumaNodes = make([]VnodeInfo, n)
+for i, v := range cVnumaNodes {
+if err := x.VnumaNodes[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field VnumaNodes: %v", err) }
+}
+}
+x.MaxGrantFrames = uint32(xc.max_grant_frames)
+x.MaxMaptrackFrames = uint32(xc.max_maptrack_frames)
+x.DeviceModelVersion = DeviceModelVersion(xc.device_model_version)
+if err := x.DeviceModelStubdomain.fromC(&xc.device_model_stubdomain);err != nil {
+return fmt.Errorf("converting field DeviceModelStubdomain: %v", err)
+}
+x.StubdomainMemkb = uint64(xc.stubdomain_memkb)
+x.StubdomainKernel = C.GoString(xc.stubdomain_kernel)
+x.StubdomainRamdisk = C.GoString(xc.stubdomain_ramdisk)
+x.DeviceModel = C.GoString(xc.device_model)
+x.DeviceModelSsidref = uint32(xc.device_model_ssidref)
+x.DeviceModelSsidLabel = C.GoString(xc.device_model_ssid_label)
+x.DeviceModelUser = C.GoString(xc.device_model_user)
+if err := x.Extra.fromC(&xc.extra);err != nil {
+return fmt.Errorf("converting field Extra: %v", err)
+}
+if err := x.ExtraPv.fromC(&xc.extra_pv);err != nil {
+return fmt.Errorf("converting field ExtraPv: %v", err)
+}
+if err := x.ExtraHvm.fromC(&xc.extra_hvm);err != nil {
+return fmt.Errorf("converting field ExtraHvm: %v", err)
+}
+if err := x.SchedParams.fromC(&xc.sched_params);err != nil {
+return fmt.Errorf("converting field SchedParams: %v", err)
+}
+x.Ioports = nil
+if n := int(xc.num_ioports); n > 0 {
+cIoports := (*[1<<28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports))[:n:n]
+x.Ioports = make([]IoportRange, n)
+for i, v := range cIoports {
+if err := x.Ioports[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Ioports: %v", err) }
+}
+}
+x.Irqs = nil
+if n := int(xc.num_irqs); n > 0 {
+cIrqs := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:n:n]
+x.Irqs = make([]uint32, n)
+for i, v := range cIrqs {
+x.Irqs[i] = uint32(v)
+}
+}
+x.Iomem = nil
+if n := int(xc.num_iomem); n > 0 {
+cIomem := (*[1<<28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:n:n]
+x.Iomem = make([]IomemRange, n)
+for i, v := range cIomem {
+if err := x.Iomem[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Iomem: %v", err) }
+}
+}
+if err := x.ClaimMode.fromC(&xc.claim_mode);err != nil {
+return fmt.Errorf("converting field ClaimMode: %v", err)
+}
+x.EventChannels = uint32(xc.event_channels)
+x.Kernel = C.GoString(xc.kernel)
+x.Cmdline = C.GoString(xc.cmdline)
+x.Ramdisk = C.GoString(xc.ramdisk)
+x.DeviceTree = C.GoString(xc.device_tree)
+if err := x.Acpi.fromC(&xc.acpi);err != nil {
+return fmt.Errorf("converting field Acpi: %v", err)
+}
+x.Bootloader = C.GoString(xc.bootloader)
+if err := x.BootloaderArgs.fromC(&xc.bootloader_args);err != nil {
+return fmt.Errorf("converting field BootloaderArgs: %v", err)
+}
+x.TimerMode = TimerMode(xc.timer_mode)
+if err := x.NestedHvm.fromC(&xc.nested_hvm);err != nil {
+return fmt.Errorf("converting field NestedHvm: %v", err)
+}
+if err := x.Apic.fromC(&xc.apic);err != nil {
+return fmt.Errorf("converting field Apic: %v", err)
+}
+if err := x.DmRestrict.fromC(&xc.dm_restrict);err != nil {
+return fmt.Errorf("converting field DmRestrict: %v", err)
+}
+x.Tee = TeeType(xc.tee)
+x.Type = DomainType(xc._type)
+switch x.Type{
+case DomainTypeHvm:
+var typeHvm DomainBuildInfoTypeUnionHvm
+if err := typeHvm.fromC(xc);err != nil {
+ return fmt.Errorf("converting field typeHvm: %v", err)
+}
+x.TypeUnion = typeHvm
+case DomainTypePv:
+var typePv DomainBuildInfoTypeUnionPv
+if err := typePv.fromC(xc);err != nil {
+ return fmt.Errorf("converting field typePv: %v", err)
+}
+x.TypeUnion = typePv
+case DomainTypePvh:
+var typePvh DomainBuildInfoTypeUnionPvh
+if err := typePvh.fromC(xc);err != nil {
+ return fmt.Errorf("converting field typePvh: %v", err)
+}
+x.TypeUnion = typePvh
+case DomainTypeInvalid:
+x.TypeUnion = nil
+default:
+return fmt.Errorf("invalid union key '%v'", x.Type)}
+x.ArchArm.GicVersion = GicVersion(xc.arch_arm.gic_version)
+x.ArchArm.Vuart = VuartType(xc.arch_arm.vuart)
+x.Altp2M = Altp2MMode(xc.altp2m)
+
+ return nil}
func (x *DomainBuildInfoTypeUnionHvm) fromC(xc *C.libxl_domain_build_info) error {
- if DomainType(xc._type) != DomainTypeHvm {
- return errors.New("expected union key DomainTypeHvm")
- }
-
- tmp := (*C.libxl_domain_build_info_type_union_hvm)(unsafe.Pointer(&xc.u[0]))
- x.Firmware = C.GoString(tmp.firmware)
- x.Bios = BiosType(tmp.bios)
- if err := x.Pae.fromC(&tmp.pae); err != nil {
- return fmt.Errorf("converting field Pae: %v", err)
- }
- if err := x.Apic.fromC(&tmp.apic); err != nil {
- return fmt.Errorf("converting field Apic: %v", err)
- }
- if err := x.Acpi.fromC(&tmp.acpi); err != nil {
- return fmt.Errorf("converting field Acpi: %v", err)
- }
- if err := x.AcpiS3.fromC(&tmp.acpi_s3); err != nil {
- return fmt.Errorf("converting field AcpiS3: %v", err)
- }
- if err := x.AcpiS4.fromC(&tmp.acpi_s4); err != nil {
- return fmt.Errorf("converting field AcpiS4: %v", err)
- }
- if err := x.AcpiLaptopSlate.fromC(&tmp.acpi_laptop_slate); err != nil {
- return fmt.Errorf("converting field AcpiLaptopSlate: %v", err)
- }
- if err := x.Nx.fromC(&tmp.nx); err != nil {
- return fmt.Errorf("converting field Nx: %v", err)
- }
- if err := x.Viridian.fromC(&tmp.viridian); err != nil {
- return fmt.Errorf("converting field Viridian: %v", err)
- }
- if err := x.ViridianEnable.fromC(&tmp.viridian_enable); err != nil {
- return fmt.Errorf("converting field ViridianEnable: %v", err)
- }
- if err := x.ViridianDisable.fromC(&tmp.viridian_disable); err != nil {
- return fmt.Errorf("converting field ViridianDisable: %v", err)
- }
- x.Timeoffset = C.GoString(tmp.timeoffset)
- if err := x.Hpet.fromC(&tmp.hpet); err != nil {
- return fmt.Errorf("converting field Hpet: %v", err)
- }
- if err := x.VptAlign.fromC(&tmp.vpt_align); err != nil {
- return fmt.Errorf("converting field VptAlign: %v", err)
- }
- x.MmioHoleMemkb = uint64(tmp.mmio_hole_memkb)
- x.TimerMode = TimerMode(tmp.timer_mode)
- if err := x.NestedHvm.fromC(&tmp.nested_hvm); err != nil {
- return fmt.Errorf("converting field NestedHvm: %v", err)
- }
- if err := x.Altp2M.fromC(&tmp.altp2m); err != nil {
- return fmt.Errorf("converting field Altp2M: %v", err)
- }
- x.SystemFirmware = C.GoString(tmp.system_firmware)
- x.SmbiosFirmware = C.GoString(tmp.smbios_firmware)
- x.AcpiFirmware = C.GoString(tmp.acpi_firmware)
- x.Hdtype = Hdtype(tmp.hdtype)
- if err := x.Nographic.fromC(&tmp.nographic); err != nil {
- return fmt.Errorf("converting field Nographic: %v", err)
- }
- if err := x.Vga.fromC(&tmp.vga); err != nil {
- return fmt.Errorf("converting field Vga: %v", err)
- }
- if err := x.Vnc.fromC(&tmp.vnc); err != nil {
- return fmt.Errorf("converting field Vnc: %v", err)
- }
- x.Keymap = C.GoString(tmp.keymap)
- if err := x.Sdl.fromC(&tmp.sdl); err != nil {
- return fmt.Errorf("converting field Sdl: %v", err)
- }
- if err := x.Spice.fromC(&tmp.spice); err != nil {
- return fmt.Errorf("converting field Spice: %v", err)
- }
- if err := x.GfxPassthru.fromC(&tmp.gfx_passthru); err != nil {
- return fmt.Errorf("converting field GfxPassthru: %v", err)
- }
- x.GfxPassthruKind = GfxPassthruKind(tmp.gfx_passthru_kind)
- x.Serial = C.GoString(tmp.serial)
- x.Boot = C.GoString(tmp.boot)
- if err := x.Usb.fromC(&tmp.usb); err != nil {
- return fmt.Errorf("converting field Usb: %v", err)
- }
- x.Usbversion = int(tmp.usbversion)
- x.Usbdevice = C.GoString(tmp.usbdevice)
- if err := x.VkbDevice.fromC(&tmp.vkb_device); err != nil {
- return fmt.Errorf("converting field VkbDevice: %v", err)
- }
- x.Soundhw = C.GoString(tmp.soundhw)
- if err := x.XenPlatformPci.fromC(&tmp.xen_platform_pci); err != nil {
- return fmt.Errorf("converting field XenPlatformPci: %v", err)
- }
- if err := x.UsbdeviceList.fromC(&tmp.usbdevice_list); err != nil {
- return fmt.Errorf("converting field UsbdeviceList: %v", err)
- }
- x.VendorDevice = VendorDevice(tmp.vendor_device)
- if err := x.MsVmGenid.fromC(&tmp.ms_vm_genid); err != nil {
- return fmt.Errorf("converting field MsVmGenid: %v", err)
- }
- if err := x.SerialList.fromC(&tmp.serial_list); err != nil {
- return fmt.Errorf("converting field SerialList: %v", err)
- }
- if err := x.Rdm.fromC(&tmp.rdm); err != nil {
- return fmt.Errorf("converting field Rdm: %v", err)
- }
- x.RdmMemBoundaryMemkb = uint64(tmp.rdm_mem_boundary_memkb)
- x.McaCaps = uint64(tmp.mca_caps)
- return nil
+if DomainType(xc._type) != DomainTypeHvm {
+return errors.New("expected union key DomainTypeHvm")
+}
+
+tmp := (*C.libxl_domain_build_info_type_union_hvm)(unsafe.Pointer(&xc.u[0]))
+x.Firmware = C.GoString(tmp.firmware)
+x.Bios = BiosType(tmp.bios)
+if err := x.Pae.fromC(&tmp.pae);err != nil {
+return fmt.Errorf("converting field Pae: %v", err)
+}
+if err := x.Apic.fromC(&tmp.apic);err != nil {
+return fmt.Errorf("converting field Apic: %v", err)
+}
+if err := x.Acpi.fromC(&tmp.acpi);err != nil {
+return fmt.Errorf("converting field Acpi: %v", err)
+}
+if err := x.AcpiS3.fromC(&tmp.acpi_s3);err != nil {
+return fmt.Errorf("converting field AcpiS3: %v", err)
+}
+if err := x.AcpiS4.fromC(&tmp.acpi_s4);err != nil {
+return fmt.Errorf("converting field AcpiS4: %v", err)
+}
+if err := x.AcpiLaptopSlate.fromC(&tmp.acpi_laptop_slate);err != nil {
+return fmt.Errorf("converting field AcpiLaptopSlate: %v", err)
+}
+if err := x.Nx.fromC(&tmp.nx);err != nil {
+return fmt.Errorf("converting field Nx: %v", err)
+}
+if err := x.Viridian.fromC(&tmp.viridian);err != nil {
+return fmt.Errorf("converting field Viridian: %v", err)
+}
+if err := x.ViridianEnable.fromC(&tmp.viridian_enable);err != nil {
+return fmt.Errorf("converting field ViridianEnable: %v", err)
+}
+if err := x.ViridianDisable.fromC(&tmp.viridian_disable);err != nil {
+return fmt.Errorf("converting field ViridianDisable: %v", err)
+}
+x.Timeoffset = C.GoString(tmp.timeoffset)
+if err := x.Hpet.fromC(&tmp.hpet);err != nil {
+return fmt.Errorf("converting field Hpet: %v", err)
+}
+if err := x.VptAlign.fromC(&tmp.vpt_align);err != nil {
+return fmt.Errorf("converting field VptAlign: %v", err)
+}
+x.MmioHoleMemkb = uint64(tmp.mmio_hole_memkb)
+x.TimerMode = TimerMode(tmp.timer_mode)
+if err := x.NestedHvm.fromC(&tmp.nested_hvm);err != nil {
+return fmt.Errorf("converting field NestedHvm: %v", err)
+}
+if err := x.Altp2M.fromC(&tmp.altp2m);err != nil {
+return fmt.Errorf("converting field Altp2M: %v", err)
+}
+x.SystemFirmware = C.GoString(tmp.system_firmware)
+x.SmbiosFirmware = C.GoString(tmp.smbios_firmware)
+x.AcpiFirmware = C.GoString(tmp.acpi_firmware)
+x.Hdtype = Hdtype(tmp.hdtype)
+if err := x.Nographic.fromC(&tmp.nographic);err != nil {
+return fmt.Errorf("converting field Nographic: %v", err)
+}
+if err := x.Vga.fromC(&tmp.vga);err != nil {
+return fmt.Errorf("converting field Vga: %v", err)
+}
+if err := x.Vnc.fromC(&tmp.vnc);err != nil {
+return fmt.Errorf("converting field Vnc: %v", err)
+}
+x.Keymap = C.GoString(tmp.keymap)
+if err := x.Sdl.fromC(&tmp.sdl);err != nil {
+return fmt.Errorf("converting field Sdl: %v", err)
+}
+if err := x.Spice.fromC(&tmp.spice);err != nil {
+return fmt.Errorf("converting field Spice: %v", err)
+}
+if err := x.GfxPassthru.fromC(&tmp.gfx_passthru);err != nil {
+return fmt.Errorf("converting field GfxPassthru: %v", err)
+}
+x.GfxPassthruKind = GfxPassthruKind(tmp.gfx_passthru_kind)
+x.Serial = C.GoString(tmp.serial)
+x.Boot = C.GoString(tmp.boot)
+if err := x.Usb.fromC(&tmp.usb);err != nil {
+return fmt.Errorf("converting field Usb: %v", err)
+}
+x.Usbversion = int(tmp.usbversion)
+x.Usbdevice = C.GoString(tmp.usbdevice)
+if err := x.VkbDevice.fromC(&tmp.vkb_device);err != nil {
+return fmt.Errorf("converting field VkbDevice: %v", err)
+}
+x.Soundhw = C.GoString(tmp.soundhw)
+if err := x.XenPlatformPci.fromC(&tmp.xen_platform_pci);err != nil {
+return fmt.Errorf("converting field XenPlatformPci: %v", err)
+}
+if err := x.UsbdeviceList.fromC(&tmp.usbdevice_list);err != nil {
+return fmt.Errorf("converting field UsbdeviceList: %v", err)
+}
+x.VendorDevice = VendorDevice(tmp.vendor_device)
+if err := x.MsVmGenid.fromC(&tmp.ms_vm_genid);err != nil {
+return fmt.Errorf("converting field MsVmGenid: %v", err)
+}
+if err := x.SerialList.fromC(&tmp.serial_list);err != nil {
+return fmt.Errorf("converting field SerialList: %v", err)
+}
+if err := x.Rdm.fromC(&tmp.rdm);err != nil {
+return fmt.Errorf("converting field Rdm: %v", err)
+}
+x.RdmMemBoundaryMemkb = uint64(tmp.rdm_mem_boundary_memkb)
+x.McaCaps = uint64(tmp.mca_caps)
+return nil
}
func (x *DomainBuildInfoTypeUnionPv) fromC(xc *C.libxl_domain_build_info) error {
- if DomainType(xc._type) != DomainTypePv {
- return errors.New("expected union key DomainTypePv")
- }
-
- tmp := (*C.libxl_domain_build_info_type_union_pv)(unsafe.Pointer(&xc.u[0]))
- x.Kernel = C.GoString(tmp.kernel)
- x.SlackMemkb = uint64(tmp.slack_memkb)
- x.Bootloader = C.GoString(tmp.bootloader)
- if err := x.BootloaderArgs.fromC(&tmp.bootloader_args); err != nil {
- return fmt.Errorf("converting field BootloaderArgs: %v", err)
- }
- x.Cmdline = C.GoString(tmp.cmdline)
- x.Ramdisk = C.GoString(tmp.ramdisk)
- x.Features = C.GoString(tmp.features)
- if err := x.E820Host.fromC(&tmp.e820_host); err != nil {
- return fmt.Errorf("converting field E820Host: %v", err)
- }
- return nil
+if DomainType(xc._type) != DomainTypePv {
+return errors.New("expected union key DomainTypePv")
+}
+
+tmp := (*C.libxl_domain_build_info_type_union_pv)(unsafe.Pointer(&xc.u[0]))
+x.Kernel = C.GoString(tmp.kernel)
+x.SlackMemkb = uint64(tmp.slack_memkb)
+x.Bootloader = C.GoString(tmp.bootloader)
+if err := x.BootloaderArgs.fromC(&tmp.bootloader_args);err != nil {
+return fmt.Errorf("converting field BootloaderArgs: %v", err)
+}
+x.Cmdline = C.GoString(tmp.cmdline)
+x.Ramdisk = C.GoString(tmp.ramdisk)
+x.Features = C.GoString(tmp.features)
+if err := x.E820Host.fromC(&tmp.e820_host);err != nil {
+return fmt.Errorf("converting field E820Host: %v", err)
+}
+return nil
}
func (x *DomainBuildInfoTypeUnionPvh) fromC(xc *C.libxl_domain_build_info) error {
- if DomainType(xc._type) != DomainTypePvh {
- return errors.New("expected union key DomainTypePvh")
- }
-
- tmp := (*C.libxl_domain_build_info_type_union_pvh)(unsafe.Pointer(&xc.u[0]))
- if err := x.Pvshim.fromC(&tmp.pvshim); err != nil {
- return fmt.Errorf("converting field Pvshim: %v", err)
- }
- x.PvshimPath = C.GoString(tmp.pvshim_path)
- x.PvshimCmdline = C.GoString(tmp.pvshim_cmdline)
- x.PvshimExtra = C.GoString(tmp.pvshim_extra)
- return nil
-}
-
-func (x *DomainBuildInfo) toC(xc *C.libxl_domain_build_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_domain_build_info_dispose(xc)
- }
- }()
-
- xc.max_vcpus = C.int(x.MaxVcpus)
- if err := x.AvailVcpus.toC(&xc.avail_vcpus); err != nil {
- return fmt.Errorf("converting field AvailVcpus: %v", err)
- }
- if err := x.Cpumap.toC(&xc.cpumap); err != nil {
- return fmt.Errorf("converting field Cpumap: %v", err)
- }
- if err := x.Nodemap.toC(&xc.nodemap); err != nil {
- return fmt.Errorf("converting field Nodemap: %v", err)
- }
- if numVcpuHardAffinity := len(x.VcpuHardAffinity); numVcpuHardAffinity > 0 {
- xc.vcpu_hard_affinity = (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuHardAffinity) * C.sizeof_libxl_bitmap))
- xc.num_vcpu_hard_affinity = C.int(numVcpuHardAffinity)
- cVcpuHardAffinity := (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_hard_affinity))[:numVcpuHardAffinity:numVcpuHardAffinity]
- for i, v := range x.VcpuHardAffinity {
- if err := v.toC(&cVcpuHardAffinity[i]); err != nil {
- return fmt.Errorf("converting field VcpuHardAffinity: %v", err)
- }
- }
- }
- if numVcpuSoftAffinity := len(x.VcpuSoftAffinity); numVcpuSoftAffinity > 0 {
- xc.vcpu_soft_affinity = (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuSoftAffinity) * C.sizeof_libxl_bitmap))
- xc.num_vcpu_soft_affinity = C.int(numVcpuSoftAffinity)
- cVcpuSoftAffinity := (*[1 << 28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_soft_affinity))[:numVcpuSoftAffinity:numVcpuSoftAffinity]
- for i, v := range x.VcpuSoftAffinity {
- if err := v.toC(&cVcpuSoftAffinity[i]); err != nil {
- return fmt.Errorf("converting field VcpuSoftAffinity: %v", err)
- }
- }
- }
- if err := x.NumaPlacement.toC(&xc.numa_placement); err != nil {
- return fmt.Errorf("converting field NumaPlacement: %v", err)
- }
- xc.tsc_mode = C.libxl_tsc_mode(x.TscMode)
- xc.max_memkb = C.uint64_t(x.MaxMemkb)
- xc.target_memkb = C.uint64_t(x.TargetMemkb)
- xc.video_memkb = C.uint64_t(x.VideoMemkb)
- xc.shadow_memkb = C.uint64_t(x.ShadowMemkb)
- xc.iommu_memkb = C.uint64_t(x.IommuMemkb)
- xc.rtc_timeoffset = C.uint32_t(x.RtcTimeoffset)
- xc.exec_ssidref = C.uint32_t(x.ExecSsidref)
- if x.ExecSsidLabel != "" {
- xc.exec_ssid_label = C.CString(x.ExecSsidLabel)
- }
- if err := x.Localtime.toC(&xc.localtime); err != nil {
- return fmt.Errorf("converting field Localtime: %v", err)
- }
- if err := x.DisableMigrate.toC(&xc.disable_migrate); err != nil {
- return fmt.Errorf("converting field DisableMigrate: %v", err)
- }
- if err := x.Cpuid.toC(&xc.cpuid); err != nil {
- return fmt.Errorf("converting field Cpuid: %v", err)
- }
- if x.BlkdevStart != "" {
- xc.blkdev_start = C.CString(x.BlkdevStart)
- }
- if numVnumaNodes := len(x.VnumaNodes); numVnumaNodes > 0 {
- xc.vnuma_nodes = (*C.libxl_vnode_info)(C.malloc(C.ulong(numVnumaNodes) * C.sizeof_libxl_vnode_info))
- xc.num_vnuma_nodes = C.int(numVnumaNodes)
- cVnumaNodes := (*[1 << 28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_nodes))[:numVnumaNodes:numVnumaNodes]
- for i, v := range x.VnumaNodes {
- if err := v.toC(&cVnumaNodes[i]); err != nil {
- return fmt.Errorf("converting field VnumaNodes: %v", err)
- }
- }
- }
- xc.max_grant_frames = C.uint32_t(x.MaxGrantFrames)
- xc.max_maptrack_frames = C.uint32_t(x.MaxMaptrackFrames)
- xc.device_model_version = C.libxl_device_model_version(x.DeviceModelVersion)
- if err := x.DeviceModelStubdomain.toC(&xc.device_model_stubdomain); err != nil {
- return fmt.Errorf("converting field DeviceModelStubdomain: %v", err)
- }
- xc.stubdomain_memkb = C.uint64_t(x.StubdomainMemkb)
- if x.StubdomainKernel != "" {
- xc.stubdomain_kernel = C.CString(x.StubdomainKernel)
- }
- if x.StubdomainRamdisk != "" {
- xc.stubdomain_ramdisk = C.CString(x.StubdomainRamdisk)
- }
- if x.DeviceModel != "" {
- xc.device_model = C.CString(x.DeviceModel)
- }
- xc.device_model_ssidref = C.uint32_t(x.DeviceModelSsidref)
- if x.DeviceModelSsidLabel != "" {
- xc.device_model_ssid_label = C.CString(x.DeviceModelSsidLabel)
- }
- if x.DeviceModelUser != "" {
- xc.device_model_user = C.CString(x.DeviceModelUser)
- }
- if err := x.Extra.toC(&xc.extra); err != nil {
- return fmt.Errorf("converting field Extra: %v", err)
- }
- if err := x.ExtraPv.toC(&xc.extra_pv); err != nil {
- return fmt.Errorf("converting field ExtraPv: %v", err)
- }
- if err := x.ExtraHvm.toC(&xc.extra_hvm); err != nil {
- return fmt.Errorf("converting field ExtraHvm: %v", err)
- }
- if err := x.SchedParams.toC(&xc.sched_params); err != nil {
- return fmt.Errorf("converting field SchedParams: %v", err)
- }
- if numIoports := len(x.Ioports); numIoports > 0 {
- xc.ioports = (*C.libxl_ioport_range)(C.malloc(C.ulong(numIoports) * C.sizeof_libxl_ioport_range))
- xc.num_ioports = C.int(numIoports)
- cIoports := (*[1 << 28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports))[:numIoports:numIoports]
- for i, v := range x.Ioports {
- if err := v.toC(&cIoports[i]); err != nil {
- return fmt.Errorf("converting field Ioports: %v", err)
- }
- }
- }
- if numIrqs := len(x.Irqs); numIrqs > 0 {
- xc.irqs = (*C.uint32_t)(C.malloc(C.size_t(numIrqs * numIrqs)))
- xc.num_irqs = C.int(numIrqs)
- cIrqs := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:numIrqs:numIrqs]
- for i, v := range x.Irqs {
- cIrqs[i] = C.uint32_t(v)
- }
- }
- if numIomem := len(x.Iomem); numIomem > 0 {
- xc.iomem = (*C.libxl_iomem_range)(C.malloc(C.ulong(numIomem) * C.sizeof_libxl_iomem_range))
- xc.num_iomem = C.int(numIomem)
- cIomem := (*[1 << 28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:numIomem:numIomem]
- for i, v := range x.Iomem {
- if err := v.toC(&cIomem[i]); err != nil {
- return fmt.Errorf("converting field Iomem: %v", err)
- }
- }
- }
- if err := x.ClaimMode.toC(&xc.claim_mode); err != nil {
- return fmt.Errorf("converting field ClaimMode: %v", err)
- }
- xc.event_channels = C.uint32_t(x.EventChannels)
- if x.Kernel != "" {
- xc.kernel = C.CString(x.Kernel)
- }
- if x.Cmdline != "" {
- xc.cmdline = C.CString(x.Cmdline)
- }
- if x.Ramdisk != "" {
- xc.ramdisk = C.CString(x.Ramdisk)
- }
- if x.DeviceTree != "" {
- xc.device_tree = C.CString(x.DeviceTree)
- }
- if err := x.Acpi.toC(&xc.acpi); err != nil {
- return fmt.Errorf("converting field Acpi: %v", err)
- }
- if x.Bootloader != "" {
- xc.bootloader = C.CString(x.Bootloader)
- }
- if err := x.BootloaderArgs.toC(&xc.bootloader_args); err != nil {
- return fmt.Errorf("converting field BootloaderArgs: %v", err)
- }
- xc.timer_mode = C.libxl_timer_mode(x.TimerMode)
- if err := x.NestedHvm.toC(&xc.nested_hvm); err != nil {
- return fmt.Errorf("converting field NestedHvm: %v", err)
- }
- if err := x.Apic.toC(&xc.apic); err != nil {
- return fmt.Errorf("converting field Apic: %v", err)
- }
- if err := x.DmRestrict.toC(&xc.dm_restrict); err != nil {
- return fmt.Errorf("converting field DmRestrict: %v", err)
- }
- xc.tee = C.libxl_tee_type(x.Tee)
- xc._type = C.libxl_domain_type(x.Type)
- switch x.Type {
- case DomainTypeHvm:
- tmp, ok := x.TypeUnion.(DomainBuildInfoTypeUnionHvm)
- if !ok {
- return errors.New("wrong type for union key type")
- }
- var hvm C.libxl_domain_build_info_type_union_hvm
- if tmp.Firmware != "" {
- hvm.firmware = C.CString(tmp.Firmware)
- }
- hvm.bios = C.libxl_bios_type(tmp.Bios)
- if err := tmp.Pae.toC(&hvm.pae); err != nil {
- return fmt.Errorf("converting field Pae: %v", err)
- }
- if err := tmp.Apic.toC(&hvm.apic); err != nil {
- return fmt.Errorf("converting field Apic: %v", err)
- }
- if err := tmp.Acpi.toC(&hvm.acpi); err != nil {
- return fmt.Errorf("converting field Acpi: %v", err)
- }
- if err := tmp.AcpiS3.toC(&hvm.acpi_s3); err != nil {
- return fmt.Errorf("converting field AcpiS3: %v", err)
- }
- if err := tmp.AcpiS4.toC(&hvm.acpi_s4); err != nil {
- return fmt.Errorf("converting field AcpiS4: %v", err)
- }
- if err := tmp.AcpiLaptopSlate.toC(&hvm.acpi_laptop_slate); err != nil {
- return fmt.Errorf("converting field AcpiLaptopSlate: %v", err)
- }
- if err := tmp.Nx.toC(&hvm.nx); err != nil {
- return fmt.Errorf("converting field Nx: %v", err)
- }
- if err := tmp.Viridian.toC(&hvm.viridian); err != nil {
- return fmt.Errorf("converting field Viridian: %v", err)
- }
- if err := tmp.ViridianEnable.toC(&hvm.viridian_enable); err != nil {
- return fmt.Errorf("converting field ViridianEnable: %v", err)
- }
- if err := tmp.ViridianDisable.toC(&hvm.viridian_disable); err != nil {
- return fmt.Errorf("converting field ViridianDisable: %v", err)
- }
- if tmp.Timeoffset != "" {
- hvm.timeoffset = C.CString(tmp.Timeoffset)
- }
- if err := tmp.Hpet.toC(&hvm.hpet); err != nil {
- return fmt.Errorf("converting field Hpet: %v", err)
- }
- if err := tmp.VptAlign.toC(&hvm.vpt_align); err != nil {
- return fmt.Errorf("converting field VptAlign: %v", err)
- }
- hvm.mmio_hole_memkb = C.uint64_t(tmp.MmioHoleMemkb)
- hvm.timer_mode = C.libxl_timer_mode(tmp.TimerMode)
- if err := tmp.NestedHvm.toC(&hvm.nested_hvm); err != nil {
- return fmt.Errorf("converting field NestedHvm: %v", err)
- }
- if err := tmp.Altp2M.toC(&hvm.altp2m); err != nil {
- return fmt.Errorf("converting field Altp2M: %v", err)
- }
- if tmp.SystemFirmware != "" {
- hvm.system_firmware = C.CString(tmp.SystemFirmware)
- }
- if tmp.SmbiosFirmware != "" {
- hvm.smbios_firmware = C.CString(tmp.SmbiosFirmware)
- }
- if tmp.AcpiFirmware != "" {
- hvm.acpi_firmware = C.CString(tmp.AcpiFirmware)
- }
- hvm.hdtype = C.libxl_hdtype(tmp.Hdtype)
- if err := tmp.Nographic.toC(&hvm.nographic); err != nil {
- return fmt.Errorf("converting field Nographic: %v", err)
- }
- if err := tmp.Vga.toC(&hvm.vga); err != nil {
- return fmt.Errorf("converting field Vga: %v", err)
- }
- if err := tmp.Vnc.toC(&hvm.vnc); err != nil {
- return fmt.Errorf("converting field Vnc: %v", err)
- }
- if tmp.Keymap != "" {
- hvm.keymap = C.CString(tmp.Keymap)
- }
- if err := tmp.Sdl.toC(&hvm.sdl); err != nil {
- return fmt.Errorf("converting field Sdl: %v", err)
- }
- if err := tmp.Spice.toC(&hvm.spice); err != nil {
- return fmt.Errorf("converting field Spice: %v", err)
- }
- if err := tmp.GfxPassthru.toC(&hvm.gfx_passthru); err != nil {
- return fmt.Errorf("converting field GfxPassthru: %v", err)
- }
- hvm.gfx_passthru_kind = C.libxl_gfx_passthru_kind(tmp.GfxPassthruKind)
- if tmp.Serial != "" {
- hvm.serial = C.CString(tmp.Serial)
- }
- if tmp.Boot != "" {
- hvm.boot = C.CString(tmp.Boot)
- }
- if err := tmp.Usb.toC(&hvm.usb); err != nil {
- return fmt.Errorf("converting field Usb: %v", err)
- }
- hvm.usbversion = C.int(tmp.Usbversion)
- if tmp.Usbdevice != "" {
- hvm.usbdevice = C.CString(tmp.Usbdevice)
- }
- if err := tmp.VkbDevice.toC(&hvm.vkb_device); err != nil {
- return fmt.Errorf("converting field VkbDevice: %v", err)
- }
- if tmp.Soundhw != "" {
- hvm.soundhw = C.CString(tmp.Soundhw)
- }
- if err := tmp.XenPlatformPci.toC(&hvm.xen_platform_pci); err != nil {
- return fmt.Errorf("converting field XenPlatformPci: %v", err)
- }
- if err := tmp.UsbdeviceList.toC(&hvm.usbdevice_list); err != nil {
- return fmt.Errorf("converting field UsbdeviceList: %v", err)
- }
- hvm.vendor_device = C.libxl_vendor_device(tmp.VendorDevice)
- if err := tmp.MsVmGenid.toC(&hvm.ms_vm_genid); err != nil {
- return fmt.Errorf("converting field MsVmGenid: %v", err)
- }
- if err := tmp.SerialList.toC(&hvm.serial_list); err != nil {
- return fmt.Errorf("converting field SerialList: %v", err)
- }
- if err := tmp.Rdm.toC(&hvm.rdm); err != nil {
- return fmt.Errorf("converting field Rdm: %v", err)
- }
- hvm.rdm_mem_boundary_memkb = C.uint64_t(tmp.RdmMemBoundaryMemkb)
- hvm.mca_caps = C.uint64_t(tmp.McaCaps)
- hvmBytes := C.GoBytes(unsafe.Pointer(&hvm), C.sizeof_libxl_domain_build_info_type_union_hvm)
- copy(xc.u[:], hvmBytes)
- case DomainTypePv:
- tmp, ok := x.TypeUnion.(DomainBuildInfoTypeUnionPv)
- if !ok {
- return errors.New("wrong type for union key type")
- }
- var pv C.libxl_domain_build_info_type_union_pv
- if tmp.Kernel != "" {
- pv.kernel = C.CString(tmp.Kernel)
- }
- pv.slack_memkb = C.uint64_t(tmp.SlackMemkb)
- if tmp.Bootloader != "" {
- pv.bootloader = C.CString(tmp.Bootloader)
- }
- if err := tmp.BootloaderArgs.toC(&pv.bootloader_args); err != nil {
- return fmt.Errorf("converting field BootloaderArgs: %v", err)
- }
- if tmp.Cmdline != "" {
- pv.cmdline = C.CString(tmp.Cmdline)
- }
- if tmp.Ramdisk != "" {
- pv.ramdisk = C.CString(tmp.Ramdisk)
- }
- if tmp.Features != "" {
- pv.features = C.CString(tmp.Features)
- }
- if err := tmp.E820Host.toC(&pv.e820_host); err != nil {
- return fmt.Errorf("converting field E820Host: %v", err)
- }
- pvBytes := C.GoBytes(unsafe.Pointer(&pv), C.sizeof_libxl_domain_build_info_type_union_pv)
- copy(xc.u[:], pvBytes)
- case DomainTypePvh:
- tmp, ok := x.TypeUnion.(DomainBuildInfoTypeUnionPvh)
- if !ok {
- return errors.New("wrong type for union key type")
- }
- var pvh C.libxl_domain_build_info_type_union_pvh
- if err := tmp.Pvshim.toC(&pvh.pvshim); err != nil {
- return fmt.Errorf("converting field Pvshim: %v", err)
- }
- if tmp.PvshimPath != "" {
- pvh.pvshim_path = C.CString(tmp.PvshimPath)
- }
- if tmp.PvshimCmdline != "" {
- pvh.pvshim_cmdline = C.CString(tmp.PvshimCmdline)
- }
- if tmp.PvshimExtra != "" {
- pvh.pvshim_extra = C.CString(tmp.PvshimExtra)
- }
- pvhBytes := C.GoBytes(unsafe.Pointer(&pvh), C.sizeof_libxl_domain_build_info_type_union_pvh)
- copy(xc.u[:], pvhBytes)
- case DomainTypeInvalid:
- break
- default:
- return fmt.Errorf("invalid union key '%v'", x.Type)
- }
- xc.arch_arm.gic_version = C.libxl_gic_version(x.ArchArm.GicVersion)
- xc.arch_arm.vuart = C.libxl_vuart_type(x.ArchArm.Vuart)
- xc.altp2m = C.libxl_altp2m_mode(x.Altp2M)
-
- return nil
+if DomainType(xc._type) != DomainTypePvh {
+return errors.New("expected union key DomainTypePvh")
+}
+
+tmp := (*C.libxl_domain_build_info_type_union_pvh)(unsafe.Pointer(&xc.u[0]))
+if err := x.Pvshim.fromC(&tmp.pvshim);err != nil {
+return fmt.Errorf("converting field Pvshim: %v", err)
+}
+x.PvshimPath = C.GoString(tmp.pvshim_path)
+x.PvshimCmdline = C.GoString(tmp.pvshim_cmdline)
+x.PvshimExtra = C.GoString(tmp.pvshim_extra)
+return nil
+}
+
+func (x *DomainBuildInfo) toC(xc *C.libxl_domain_build_info) (err error){defer func(){
+if err != nil{
+C.libxl_domain_build_info_dispose(xc)}
+}()
+
+xc.max_vcpus = C.int(x.MaxVcpus)
+if err := x.AvailVcpus.toC(&xc.avail_vcpus); err != nil {
+return fmt.Errorf("converting field AvailVcpus: %v", err)
+}
+if err := x.Cpumap.toC(&xc.cpumap); err != nil {
+return fmt.Errorf("converting field Cpumap: %v", err)
+}
+if err := x.Nodemap.toC(&xc.nodemap); err != nil {
+return fmt.Errorf("converting field Nodemap: %v", err)
+}
+if numVcpuHardAffinity := len(x.VcpuHardAffinity); numVcpuHardAffinity > 0 {
+xc.vcpu_hard_affinity = (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuHardAffinity)*C.sizeof_libxl_bitmap))
+xc.num_vcpu_hard_affinity = C.int(numVcpuHardAffinity)
+cVcpuHardAffinity := (*[1<<28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_hard_affinity))[:numVcpuHardAffinity:numVcpuHardAffinity]
+for i,v := range x.VcpuHardAffinity {
+if err := v.toC(&cVcpuHardAffinity[i]); err != nil {
+return fmt.Errorf("converting field VcpuHardAffinity: %v", err)
+}
+}
+}
+if numVcpuSoftAffinity := len(x.VcpuSoftAffinity); numVcpuSoftAffinity > 0 {
+xc.vcpu_soft_affinity = (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuSoftAffinity)*C.sizeof_libxl_bitmap))
+xc.num_vcpu_soft_affinity = C.int(numVcpuSoftAffinity)
+cVcpuSoftAffinity := (*[1<<28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_soft_affinity))[:numVcpuSoftAffinity:numVcpuSoftAffinity]
+for i,v := range x.VcpuSoftAffinity {
+if err := v.toC(&cVcpuSoftAffinity[i]); err != nil {
+return fmt.Errorf("converting field VcpuSoftAffinity: %v", err)
}
+}
+}
+if err := x.NumaPlacement.toC(&xc.numa_placement); err != nil {
+return fmt.Errorf("converting field NumaPlacement: %v", err)
+}
+xc.tsc_mode = C.libxl_tsc_mode(x.TscMode)
+xc.max_memkb = C.uint64_t(x.MaxMemkb)
+xc.target_memkb = C.uint64_t(x.TargetMemkb)
+xc.video_memkb = C.uint64_t(x.VideoMemkb)
+xc.shadow_memkb = C.uint64_t(x.ShadowMemkb)
+xc.iommu_memkb = C.uint64_t(x.IommuMemkb)
+xc.rtc_timeoffset = C.uint32_t(x.RtcTimeoffset)
+xc.exec_ssidref = C.uint32_t(x.ExecSsidref)
+if x.ExecSsidLabel != "" {
+xc.exec_ssid_label = C.CString(x.ExecSsidLabel)}
+if err := x.Localtime.toC(&xc.localtime); err != nil {
+return fmt.Errorf("converting field Localtime: %v", err)
+}
+if err := x.DisableMigrate.toC(&xc.disable_migrate); err != nil {
+return fmt.Errorf("converting field DisableMigrate: %v", err)
+}
+if err := x.Cpuid.toC(&xc.cpuid); err != nil {
+return fmt.Errorf("converting field Cpuid: %v", err)
+}
+if x.BlkdevStart != "" {
+xc.blkdev_start = C.CString(x.BlkdevStart)}
+if numVnumaNodes := len(x.VnumaNodes); numVnumaNodes > 0 {
+xc.vnuma_nodes = (*C.libxl_vnode_info)(C.malloc(C.ulong(numVnumaNodes)*C.sizeof_libxl_vnode_info))
+xc.num_vnuma_nodes = C.int(numVnumaNodes)
+cVnumaNodes := (*[1<<28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_nodes))[:numVnumaNodes:numVnumaNodes]
+for i,v := range x.VnumaNodes {
+if err := v.toC(&cVnumaNodes[i]); err != nil {
+return fmt.Errorf("converting field VnumaNodes: %v", err)
+}
+}
+}
+xc.max_grant_frames = C.uint32_t(x.MaxGrantFrames)
+xc.max_maptrack_frames = C.uint32_t(x.MaxMaptrackFrames)
+xc.device_model_version = C.libxl_device_model_version(x.DeviceModelVersion)
+if err := x.DeviceModelStubdomain.toC(&xc.device_model_stubdomain); err != nil {
+return fmt.Errorf("converting field DeviceModelStubdomain: %v", err)
+}
+xc.stubdomain_memkb = C.uint64_t(x.StubdomainMemkb)
+if x.StubdomainKernel != "" {
+xc.stubdomain_kernel = C.CString(x.StubdomainKernel)}
+if x.StubdomainRamdisk != "" {
+xc.stubdomain_ramdisk = C.CString(x.StubdomainRamdisk)}
+if x.DeviceModel != "" {
+xc.device_model = C.CString(x.DeviceModel)}
+xc.device_model_ssidref = C.uint32_t(x.DeviceModelSsidref)
+if x.DeviceModelSsidLabel != "" {
+xc.device_model_ssid_label = C.CString(x.DeviceModelSsidLabel)}
+if x.DeviceModelUser != "" {
+xc.device_model_user = C.CString(x.DeviceModelUser)}
+if err := x.Extra.toC(&xc.extra); err != nil {
+return fmt.Errorf("converting field Extra: %v", err)
+}
+if err := x.ExtraPv.toC(&xc.extra_pv); err != nil {
+return fmt.Errorf("converting field ExtraPv: %v", err)
+}
+if err := x.ExtraHvm.toC(&xc.extra_hvm); err != nil {
+return fmt.Errorf("converting field ExtraHvm: %v", err)
+}
+if err := x.SchedParams.toC(&xc.sched_params); err != nil {
+return fmt.Errorf("converting field SchedParams: %v", err)
+}
+if numIoports := len(x.Ioports); numIoports > 0 {
+xc.ioports = (*C.libxl_ioport_range)(C.malloc(C.ulong(numIoports)*C.sizeof_libxl_ioport_range))
+xc.num_ioports = C.int(numIoports)
+cIoports := (*[1<<28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports))[:numIoports:numIoports]
+for i,v := range x.Ioports {
+if err := v.toC(&cIoports[i]); err != nil {
+return fmt.Errorf("converting field Ioports: %v", err)
+}
+}
+}
+if numIrqs := len(x.Irqs); numIrqs > 0 {
+xc.irqs = (*C.uint32_t)(C.malloc(C.size_t(numIrqs*numIrqs)))
+xc.num_irqs = C.int(numIrqs)
+cIrqs := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:numIrqs:numIrqs]
+for i,v := range x.Irqs {
+cIrqs[i] = C.uint32_t(v)
+}
+}
+if numIomem := len(x.Iomem); numIomem > 0 {
+xc.iomem = (*C.libxl_iomem_range)(C.malloc(C.ulong(numIomem)*C.sizeof_libxl_iomem_range))
+xc.num_iomem = C.int(numIomem)
+cIomem := (*[1<<28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:numIomem:numIomem]
+for i,v := range x.Iomem {
+if err := v.toC(&cIomem[i]); err != nil {
+return fmt.Errorf("converting field Iomem: %v", err)
+}
+}
+}
+if err := x.ClaimMode.toC(&xc.claim_mode); err != nil {
+return fmt.Errorf("converting field ClaimMode: %v", err)
+}
+xc.event_channels = C.uint32_t(x.EventChannels)
+if x.Kernel != "" {
+xc.kernel = C.CString(x.Kernel)}
+if x.Cmdline != "" {
+xc.cmdline = C.CString(x.Cmdline)}
+if x.Ramdisk != "" {
+xc.ramdisk = C.CString(x.Ramdisk)}
+if x.DeviceTree != "" {
+xc.device_tree = C.CString(x.DeviceTree)}
+if err := x.Acpi.toC(&xc.acpi); err != nil {
+return fmt.Errorf("converting field Acpi: %v", err)
+}
+if x.Bootloader != "" {
+xc.bootloader = C.CString(x.Bootloader)}
+if err := x.BootloaderArgs.toC(&xc.bootloader_args); err != nil {
+return fmt.Errorf("converting field BootloaderArgs: %v", err)
+}
+xc.timer_mode = C.libxl_timer_mode(x.TimerMode)
+if err := x.NestedHvm.toC(&xc.nested_hvm); err != nil {
+return fmt.Errorf("converting field NestedHvm: %v", err)
+}
+if err := x.Apic.toC(&xc.apic); err != nil {
+return fmt.Errorf("converting field Apic: %v", err)
+}
+if err := x.DmRestrict.toC(&xc.dm_restrict); err != nil {
+return fmt.Errorf("converting field DmRestrict: %v", err)
+}
+xc.tee = C.libxl_tee_type(x.Tee)
+xc._type = C.libxl_domain_type(x.Type)
+switch x.Type{
+case DomainTypeHvm:
+tmp, ok := x.TypeUnion.(DomainBuildInfoTypeUnionHvm)
+if !ok {
+return errors.New("wrong type for union key type")
+}
+var hvm C.libxl_domain_build_info_type_union_hvm
+if tmp.Firmware != "" {
+hvm.firmware = C.CString(tmp.Firmware)}
+hvm.bios = C.libxl_bios_type(tmp.Bios)
+if err := tmp.Pae.toC(&hvm.pae); err != nil {
+return fmt.Errorf("converting field Pae: %v", err)
+}
+if err := tmp.Apic.toC(&hvm.apic); err != nil {
+return fmt.Errorf("converting field Apic: %v", err)
+}
+if err := tmp.Acpi.toC(&hvm.acpi); err != nil {
+return fmt.Errorf("converting field Acpi: %v", err)
+}
+if err := tmp.AcpiS3.toC(&hvm.acpi_s3); err != nil {
+return fmt.Errorf("converting field AcpiS3: %v", err)
+}
+if err := tmp.AcpiS4.toC(&hvm.acpi_s4); err != nil {
+return fmt.Errorf("converting field AcpiS4: %v", err)
+}
+if err := tmp.AcpiLaptopSlate.toC(&hvm.acpi_laptop_slate); err != nil {
+return fmt.Errorf("converting field AcpiLaptopSlate: %v", err)
+}
+if err := tmp.Nx.toC(&hvm.nx); err != nil {
+return fmt.Errorf("converting field Nx: %v", err)
+}
+if err := tmp.Viridian.toC(&hvm.viridian); err != nil {
+return fmt.Errorf("converting field Viridian: %v", err)
+}
+if err := tmp.ViridianEnable.toC(&hvm.viridian_enable); err != nil {
+return fmt.Errorf("converting field ViridianEnable: %v", err)
+}
+if err := tmp.ViridianDisable.toC(&hvm.viridian_disable); err != nil {
+return fmt.Errorf("converting field ViridianDisable: %v", err)
+}
+if tmp.Timeoffset != "" {
+hvm.timeoffset = C.CString(tmp.Timeoffset)}
+if err := tmp.Hpet.toC(&hvm.hpet); err != nil {
+return fmt.Errorf("converting field Hpet: %v", err)
+}
+if err := tmp.VptAlign.toC(&hvm.vpt_align); err != nil {
+return fmt.Errorf("converting field VptAlign: %v", err)
+}
+hvm.mmio_hole_memkb = C.uint64_t(tmp.MmioHoleMemkb)
+hvm.timer_mode = C.libxl_timer_mode(tmp.TimerMode)
+if err := tmp.NestedHvm.toC(&hvm.nested_hvm); err != nil {
+return fmt.Errorf("converting field NestedHvm: %v", err)
+}
+if err := tmp.Altp2M.toC(&hvm.altp2m); err != nil {
+return fmt.Errorf("converting field Altp2M: %v", err)
+}
+if tmp.SystemFirmware != "" {
+hvm.system_firmware = C.CString(tmp.SystemFirmware)}
+if tmp.SmbiosFirmware != "" {
+hvm.smbios_firmware = C.CString(tmp.SmbiosFirmware)}
+if tmp.AcpiFirmware != "" {
+hvm.acpi_firmware = C.CString(tmp.AcpiFirmware)}
+hvm.hdtype = C.libxl_hdtype(tmp.Hdtype)
+if err := tmp.Nographic.toC(&hvm.nographic); err != nil {
+return fmt.Errorf("converting field Nographic: %v", err)
+}
+if err := tmp.Vga.toC(&hvm.vga); err != nil {
+return fmt.Errorf("converting field Vga: %v", err)
+}
+if err := tmp.Vnc.toC(&hvm.vnc); err != nil {
+return fmt.Errorf("converting field Vnc: %v", err)
+}
+if tmp.Keymap != "" {
+hvm.keymap = C.CString(tmp.Keymap)}
+if err := tmp.Sdl.toC(&hvm.sdl); err != nil {
+return fmt.Errorf("converting field Sdl: %v", err)
+}
+if err := tmp.Spice.toC(&hvm.spice); err != nil {
+return fmt.Errorf("converting field Spice: %v", err)
+}
+if err := tmp.GfxPassthru.toC(&hvm.gfx_passthru); err != nil {
+return fmt.Errorf("converting field GfxPassthru: %v", err)
+}
+hvm.gfx_passthru_kind = C.libxl_gfx_passthru_kind(tmp.GfxPassthruKind)
+if tmp.Serial != "" {
+hvm.serial = C.CString(tmp.Serial)}
+if tmp.Boot != "" {
+hvm.boot = C.CString(tmp.Boot)}
+if err := tmp.Usb.toC(&hvm.usb); err != nil {
+return fmt.Errorf("converting field Usb: %v", err)
+}
+hvm.usbversion = C.int(tmp.Usbversion)
+if tmp.Usbdevice != "" {
+hvm.usbdevice = C.CString(tmp.Usbdevice)}
+if err := tmp.VkbDevice.toC(&hvm.vkb_device); err != nil {
+return fmt.Errorf("converting field VkbDevice: %v", err)
+}
+if tmp.Soundhw != "" {
+hvm.soundhw = C.CString(tmp.Soundhw)}
+if err := tmp.XenPlatformPci.toC(&hvm.xen_platform_pci); err != nil {
+return fmt.Errorf("converting field XenPlatformPci: %v", err)
+}
+if err := tmp.UsbdeviceList.toC(&hvm.usbdevice_list); err != nil {
+return fmt.Errorf("converting field UsbdeviceList: %v", err)
+}
+hvm.vendor_device = C.libxl_vendor_device(tmp.VendorDevice)
+if err := tmp.MsVmGenid.toC(&hvm.ms_vm_genid); err != nil {
+return fmt.Errorf("converting field MsVmGenid: %v", err)
+}
+if err := tmp.SerialList.toC(&hvm.serial_list); err != nil {
+return fmt.Errorf("converting field SerialList: %v", err)
+}
+if err := tmp.Rdm.toC(&hvm.rdm); err != nil {
+return fmt.Errorf("converting field Rdm: %v", err)
+}
+hvm.rdm_mem_boundary_memkb = C.uint64_t(tmp.RdmMemBoundaryMemkb)
+hvm.mca_caps = C.uint64_t(tmp.McaCaps)
+hvmBytes := C.GoBytes(unsafe.Pointer(&hvm),C.sizeof_libxl_domain_build_info_type_union_hvm)
+copy(xc.u[:],hvmBytes)
+case DomainTypePv:
+tmp, ok := x.TypeUnion.(DomainBuildInfoTypeUnionPv)
+if !ok {
+return errors.New("wrong type for union key type")
+}
+var pv C.libxl_domain_build_info_type_union_pv
+if tmp.Kernel != "" {
+pv.kernel = C.CString(tmp.Kernel)}
+pv.slack_memkb = C.uint64_t(tmp.SlackMemkb)
+if tmp.Bootloader != "" {
+pv.bootloader = C.CString(tmp.Bootloader)}
+if err := tmp.BootloaderArgs.toC(&pv.bootloader_args); err != nil {
+return fmt.Errorf("converting field BootloaderArgs: %v", err)
+}
+if tmp.Cmdline != "" {
+pv.cmdline = C.CString(tmp.Cmdline)}
+if tmp.Ramdisk != "" {
+pv.ramdisk = C.CString(tmp.Ramdisk)}
+if tmp.Features != "" {
+pv.features = C.CString(tmp.Features)}
+if err := tmp.E820Host.toC(&pv.e820_host); err != nil {
+return fmt.Errorf("converting field E820Host: %v", err)
+}
+pvBytes := C.GoBytes(unsafe.Pointer(&pv),C.sizeof_libxl_domain_build_info_type_union_pv)
+copy(xc.u[:],pvBytes)
+case DomainTypePvh:
+tmp, ok := x.TypeUnion.(DomainBuildInfoTypeUnionPvh)
+if !ok {
+return errors.New("wrong type for union key type")
+}
+var pvh C.libxl_domain_build_info_type_union_pvh
+if err := tmp.Pvshim.toC(&pvh.pvshim); err != nil {
+return fmt.Errorf("converting field Pvshim: %v", err)
+}
+if tmp.PvshimPath != "" {
+pvh.pvshim_path = C.CString(tmp.PvshimPath)}
+if tmp.PvshimCmdline != "" {
+pvh.pvshim_cmdline = C.CString(tmp.PvshimCmdline)}
+if tmp.PvshimExtra != "" {
+pvh.pvshim_extra = C.CString(tmp.PvshimExtra)}
+pvhBytes := C.GoBytes(unsafe.Pointer(&pvh),C.sizeof_libxl_domain_build_info_type_union_pvh)
+copy(xc.u[:],pvhBytes)
+case DomainTypeInvalid:
+break
+default:
+return fmt.Errorf("invalid union key '%v'", x.Type)}
+xc.arch_arm.gic_version = C.libxl_gic_version(x.ArchArm.GicVersion)
+xc.arch_arm.vuart = C.libxl_vuart_type(x.ArchArm.Vuart)
+xc.altp2m = C.libxl_altp2m_mode(x.Altp2M)
+
+ return nil
+ }
// NewDeviceVfb returns an instance of DeviceVfb initialized with defaults.
func NewDeviceVfb() (*DeviceVfb, error) {
- var (
- x DeviceVfb
- xc C.libxl_device_vfb
- )
+var (
+x DeviceVfb
+xc C.libxl_device_vfb)
- C.libxl_device_vfb_init(&xc)
- defer C.libxl_device_vfb_dispose(&xc)
+C.libxl_device_vfb_init(&xc)
+defer C.libxl_device_vfb_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) error {
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
- x.Devid = Devid(xc.devid)
- if err := x.Vnc.fromC(&xc.vnc); err != nil {
- return fmt.Errorf("converting field Vnc: %v", err)
- }
- if err := x.Sdl.fromC(&xc.sdl); err != nil {
- return fmt.Errorf("converting field Sdl: %v", err)
- }
- x.Keymap = C.GoString(xc.keymap)
-
- return nil
-}
-
-func (x *DeviceVfb) toC(xc *C.libxl_device_vfb) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_vfb_dispose(xc)
- }
- }()
-
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
- xc.devid = C.libxl_devid(x.Devid)
- if err := x.Vnc.toC(&xc.vnc); err != nil {
- return fmt.Errorf("converting field Vnc: %v", err)
- }
- if err := x.Sdl.toC(&xc.sdl); err != nil {
- return fmt.Errorf("converting field Sdl: %v", err)
- }
- if x.Keymap != "" {
- xc.keymap = C.CString(x.Keymap)
- }
-
- return nil
+ x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+x.Devid = Devid(xc.devid)
+if err := x.Vnc.fromC(&xc.vnc);err != nil {
+return fmt.Errorf("converting field Vnc: %v", err)
}
+if err := x.Sdl.fromC(&xc.sdl);err != nil {
+return fmt.Errorf("converting field Sdl: %v", err)
+}
+x.Keymap = C.GoString(xc.keymap)
+
+ return nil}
+
+func (x *DeviceVfb) toC(xc *C.libxl_device_vfb) (err error){defer func(){
+if err != nil{
+C.libxl_device_vfb_dispose(xc)}
+}()
+
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+xc.devid = C.libxl_devid(x.Devid)
+if err := x.Vnc.toC(&xc.vnc); err != nil {
+return fmt.Errorf("converting field Vnc: %v", err)
+}
+if err := x.Sdl.toC(&xc.sdl); err != nil {
+return fmt.Errorf("converting field Sdl: %v", err)
+}
+if x.Keymap != "" {
+xc.keymap = C.CString(x.Keymap)}
+
+ return nil
+ }
// NewDeviceVkb returns an instance of DeviceVkb initialized with defaults.
func NewDeviceVkb() (*DeviceVkb, error) {
- var (
- x DeviceVkb
- xc C.libxl_device_vkb
- )
+var (
+x DeviceVkb
+xc C.libxl_device_vkb)
- C.libxl_device_vkb_init(&xc)
- defer C.libxl_device_vkb_dispose(&xc)
+C.libxl_device_vkb_init(&xc)
+defer C.libxl_device_vkb_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceVkb) fromC(xc *C.libxl_device_vkb) error {
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
- x.Devid = Devid(xc.devid)
- x.BackendType = VkbBackend(xc.backend_type)
- x.UniqueId = C.GoString(xc.unique_id)
- x.FeatureDisableKeyboard = bool(xc.feature_disable_keyboard)
- x.FeatureDisablePointer = bool(xc.feature_disable_pointer)
- x.FeatureAbsPointer = bool(xc.feature_abs_pointer)
- x.FeatureRawPointer = bool(xc.feature_raw_pointer)
- x.FeatureMultiTouch = bool(xc.feature_multi_touch)
- x.Width = uint32(xc.width)
- x.Height = uint32(xc.height)
- x.MultiTouchWidth = uint32(xc.multi_touch_width)
- x.MultiTouchHeight = uint32(xc.multi_touch_height)
- x.MultiTouchNumContacts = uint32(xc.multi_touch_num_contacts)
-
- return nil
-}
-
-func (x *DeviceVkb) toC(xc *C.libxl_device_vkb) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_vkb_dispose(xc)
- }
- }()
-
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
- xc.devid = C.libxl_devid(x.Devid)
- xc.backend_type = C.libxl_vkb_backend(x.BackendType)
- if x.UniqueId != "" {
- xc.unique_id = C.CString(x.UniqueId)
- }
- xc.feature_disable_keyboard = C.bool(x.FeatureDisableKeyboard)
- xc.feature_disable_pointer = C.bool(x.FeatureDisablePointer)
- xc.feature_abs_pointer = C.bool(x.FeatureAbsPointer)
- xc.feature_raw_pointer = C.bool(x.FeatureRawPointer)
- xc.feature_multi_touch = C.bool(x.FeatureMultiTouch)
- xc.width = C.uint32_t(x.Width)
- xc.height = C.uint32_t(x.Height)
- xc.multi_touch_width = C.uint32_t(x.MultiTouchWidth)
- xc.multi_touch_height = C.uint32_t(x.MultiTouchHeight)
- xc.multi_touch_num_contacts = C.uint32_t(x.MultiTouchNumContacts)
-
- return nil
-}
+ x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+x.Devid = Devid(xc.devid)
+x.BackendType = VkbBackend(xc.backend_type)
+x.UniqueId = C.GoString(xc.unique_id)
+x.FeatureDisableKeyboard = bool(xc.feature_disable_keyboard)
+x.FeatureDisablePointer = bool(xc.feature_disable_pointer)
+x.FeatureAbsPointer = bool(xc.feature_abs_pointer)
+x.FeatureRawPointer = bool(xc.feature_raw_pointer)
+x.FeatureMultiTouch = bool(xc.feature_multi_touch)
+x.Width = uint32(xc.width)
+x.Height = uint32(xc.height)
+x.MultiTouchWidth = uint32(xc.multi_touch_width)
+x.MultiTouchHeight = uint32(xc.multi_touch_height)
+x.MultiTouchNumContacts = uint32(xc.multi_touch_num_contacts)
+
+ return nil}
+
+func (x *DeviceVkb) toC(xc *C.libxl_device_vkb) (err error){defer func(){
+if err != nil{
+C.libxl_device_vkb_dispose(xc)}
+}()
+
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+xc.devid = C.libxl_devid(x.Devid)
+xc.backend_type = C.libxl_vkb_backend(x.BackendType)
+if x.UniqueId != "" {
+xc.unique_id = C.CString(x.UniqueId)}
+xc.feature_disable_keyboard = C.bool(x.FeatureDisableKeyboard)
+xc.feature_disable_pointer = C.bool(x.FeatureDisablePointer)
+xc.feature_abs_pointer = C.bool(x.FeatureAbsPointer)
+xc.feature_raw_pointer = C.bool(x.FeatureRawPointer)
+xc.feature_multi_touch = C.bool(x.FeatureMultiTouch)
+xc.width = C.uint32_t(x.Width)
+xc.height = C.uint32_t(x.Height)
+xc.multi_touch_width = C.uint32_t(x.MultiTouchWidth)
+xc.multi_touch_height = C.uint32_t(x.MultiTouchHeight)
+xc.multi_touch_num_contacts = C.uint32_t(x.MultiTouchNumContacts)
+
+ return nil
+ }
// NewDeviceDisk returns an instance of DeviceDisk initialized with defaults.
func NewDeviceDisk() (*DeviceDisk, error) {
- var (
- x DeviceDisk
- xc C.libxl_device_disk
- )
+var (
+x DeviceDisk
+xc C.libxl_device_disk)
- C.libxl_device_disk_init(&xc)
- defer C.libxl_device_disk_dispose(&xc)
+C.libxl_device_disk_init(&xc)
+defer C.libxl_device_disk_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceDisk) fromC(xc *C.libxl_device_disk) error {
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
- x.PdevPath = C.GoString(xc.pdev_path)
- x.Vdev = C.GoString(xc.vdev)
- x.Backend = DiskBackend(xc.backend)
- x.Format = DiskFormat(xc.format)
- x.Script = C.GoString(xc.script)
- x.Removable = int(xc.removable)
- x.Readwrite = int(xc.readwrite)
- x.IsCdrom = int(xc.is_cdrom)
- x.DirectIoSafe = bool(xc.direct_io_safe)
- if err := x.DiscardEnable.fromC(&xc.discard_enable); err != nil {
- return fmt.Errorf("converting field DiscardEnable: %v", err)
- }
- if err := x.ColoEnable.fromC(&xc.colo_enable); err != nil {
- return fmt.Errorf("converting field ColoEnable: %v", err)
- }
- if err := x.ColoRestoreEnable.fromC(&xc.colo_restore_enable); err != nil {
- return fmt.Errorf("converting field ColoRestoreEnable: %v", err)
- }
- x.ColoHost = C.GoString(xc.colo_host)
- x.ColoPort = int(xc.colo_port)
- x.ColoExport = C.GoString(xc.colo_export)
- x.ActiveDisk = C.GoString(xc.active_disk)
- x.HiddenDisk = C.GoString(xc.hidden_disk)
-
- return nil
-}
-
-func (x *DeviceDisk) toC(xc *C.libxl_device_disk) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_disk_dispose(xc)
- }
- }()
-
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
- if x.PdevPath != "" {
- xc.pdev_path = C.CString(x.PdevPath)
- }
- if x.Vdev != "" {
- xc.vdev = C.CString(x.Vdev)
- }
- xc.backend = C.libxl_disk_backend(x.Backend)
- xc.format = C.libxl_disk_format(x.Format)
- if x.Script != "" {
- xc.script = C.CString(x.Script)
- }
- xc.removable = C.int(x.Removable)
- xc.readwrite = C.int(x.Readwrite)
- xc.is_cdrom = C.int(x.IsCdrom)
- xc.direct_io_safe = C.bool(x.DirectIoSafe)
- if err := x.DiscardEnable.toC(&xc.discard_enable); err != nil {
- return fmt.Errorf("converting field DiscardEnable: %v", err)
- }
- if err := x.ColoEnable.toC(&xc.colo_enable); err != nil {
- return fmt.Errorf("converting field ColoEnable: %v", err)
- }
- if err := x.ColoRestoreEnable.toC(&xc.colo_restore_enable); err != nil {
- return fmt.Errorf("converting field ColoRestoreEnable: %v", err)
- }
- if x.ColoHost != "" {
- xc.colo_host = C.CString(x.ColoHost)
- }
- xc.colo_port = C.int(x.ColoPort)
- if x.ColoExport != "" {
- xc.colo_export = C.CString(x.ColoExport)
- }
- if x.ActiveDisk != "" {
- xc.active_disk = C.CString(x.ActiveDisk)
- }
- if x.HiddenDisk != "" {
- xc.hidden_disk = C.CString(x.HiddenDisk)
- }
-
- return nil
-}
+ x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+x.PdevPath = C.GoString(xc.pdev_path)
+x.Vdev = C.GoString(xc.vdev)
+x.Backend = DiskBackend(xc.backend)
+x.Format = DiskFormat(xc.format)
+x.Script = C.GoString(xc.script)
+x.Removable = int(xc.removable)
+x.Readwrite = int(xc.readwrite)
+x.IsCdrom = int(xc.is_cdrom)
+x.DirectIoSafe = bool(xc.direct_io_safe)
+if err := x.DiscardEnable.fromC(&xc.discard_enable);err != nil {
+return fmt.Errorf("converting field DiscardEnable: %v", err)
+}
+if err := x.ColoEnable.fromC(&xc.colo_enable);err != nil {
+return fmt.Errorf("converting field ColoEnable: %v", err)
+}
+if err := x.ColoRestoreEnable.fromC(&xc.colo_restore_enable);err != nil {
+return fmt.Errorf("converting field ColoRestoreEnable: %v", err)
+}
+x.ColoHost = C.GoString(xc.colo_host)
+x.ColoPort = int(xc.colo_port)
+x.ColoExport = C.GoString(xc.colo_export)
+x.ActiveDisk = C.GoString(xc.active_disk)
+x.HiddenDisk = C.GoString(xc.hidden_disk)
+
+ return nil}
+
+func (x *DeviceDisk) toC(xc *C.libxl_device_disk) (err error){defer func(){
+if err != nil{
+C.libxl_device_disk_dispose(xc)}
+}()
+
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+if x.PdevPath != "" {
+xc.pdev_path = C.CString(x.PdevPath)}
+if x.Vdev != "" {
+xc.vdev = C.CString(x.Vdev)}
+xc.backend = C.libxl_disk_backend(x.Backend)
+xc.format = C.libxl_disk_format(x.Format)
+if x.Script != "" {
+xc.script = C.CString(x.Script)}
+xc.removable = C.int(x.Removable)
+xc.readwrite = C.int(x.Readwrite)
+xc.is_cdrom = C.int(x.IsCdrom)
+xc.direct_io_safe = C.bool(x.DirectIoSafe)
+if err := x.DiscardEnable.toC(&xc.discard_enable); err != nil {
+return fmt.Errorf("converting field DiscardEnable: %v", err)
+}
+if err := x.ColoEnable.toC(&xc.colo_enable); err != nil {
+return fmt.Errorf("converting field ColoEnable: %v", err)
+}
+if err := x.ColoRestoreEnable.toC(&xc.colo_restore_enable); err != nil {
+return fmt.Errorf("converting field ColoRestoreEnable: %v", err)
+}
+if x.ColoHost != "" {
+xc.colo_host = C.CString(x.ColoHost)}
+xc.colo_port = C.int(x.ColoPort)
+if x.ColoExport != "" {
+xc.colo_export = C.CString(x.ColoExport)}
+if x.ActiveDisk != "" {
+xc.active_disk = C.CString(x.ActiveDisk)}
+if x.HiddenDisk != "" {
+xc.hidden_disk = C.CString(x.HiddenDisk)}
+
+ return nil
+ }
// NewDeviceNic returns an instance of DeviceNic initialized with defaults.
func NewDeviceNic() (*DeviceNic, error) {
- var (
- x DeviceNic
- xc C.libxl_device_nic
- )
+var (
+x DeviceNic
+xc C.libxl_device_nic)
- C.libxl_device_nic_init(&xc)
- defer C.libxl_device_nic_dispose(&xc)
+C.libxl_device_nic_init(&xc)
+defer C.libxl_device_nic_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceNic) fromC(xc *C.libxl_device_nic) error {
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
- x.Devid = Devid(xc.devid)
- x.Mtu = int(xc.mtu)
- x.Model = C.GoString(xc.model)
- if err := x.Mac.fromC(&xc.mac); err != nil {
- return fmt.Errorf("converting field Mac: %v", err)
- }
- x.Ip = C.GoString(xc.ip)
- x.Bridge = C.GoString(xc.bridge)
- x.Ifname = C.GoString(xc.ifname)
- x.Script = C.GoString(xc.script)
- x.Nictype = NicType(xc.nictype)
- x.RateBytesPerInterval = uint64(xc.rate_bytes_per_interval)
- x.RateIntervalUsecs = uint32(xc.rate_interval_usecs)
- x.Gatewaydev = C.GoString(xc.gatewaydev)
- x.ColoftForwarddev = C.GoString(xc.coloft_forwarddev)
- x.ColoSockMirrorId = C.GoString(xc.colo_sock_mirror_id)
- x.ColoSockMirrorIp = C.GoString(xc.colo_sock_mirror_ip)
- x.ColoSockMirrorPort = C.GoString(xc.colo_sock_mirror_port)
- x.ColoSockComparePriInId = C.GoString(xc.colo_sock_compare_pri_in_id)
- x.ColoSockComparePriInIp = C.GoString(xc.colo_sock_compare_pri_in_ip)
- x.ColoSockComparePriInPort = C.GoString(xc.colo_sock_compare_pri_in_port)
- x.ColoSockCompareSecInId = C.GoString(xc.colo_sock_compare_sec_in_id)
- x.ColoSockCompareSecInIp = C.GoString(xc.colo_sock_compare_sec_in_ip)
- x.ColoSockCompareSecInPort = C.GoString(xc.colo_sock_compare_sec_in_port)
- x.ColoSockCompareNotifyId = C.GoString(xc.colo_sock_compare_notify_id)
- x.ColoSockCompareNotifyIp = C.GoString(xc.colo_sock_compare_notify_ip)
- x.ColoSockCompareNotifyPort = C.GoString(xc.colo_sock_compare_notify_port)
- x.ColoSockRedirector0Id = C.GoString(xc.colo_sock_redirector0_id)
- x.ColoSockRedirector0Ip = C.GoString(xc.colo_sock_redirector0_ip)
- x.ColoSockRedirector0Port = C.GoString(xc.colo_sock_redirector0_port)
- x.ColoSockRedirector1Id = C.GoString(xc.colo_sock_redirector1_id)
- x.ColoSockRedirector1Ip = C.GoString(xc.colo_sock_redirector1_ip)
- x.ColoSockRedirector1Port = C.GoString(xc.colo_sock_redirector1_port)
- x.ColoSockRedirector2Id = C.GoString(xc.colo_sock_redirector2_id)
- x.ColoSockRedirector2Ip = C.GoString(xc.colo_sock_redirector2_ip)
- x.ColoSockRedirector2Port = C.GoString(xc.colo_sock_redirector2_port)
- x.ColoFilterMirrorQueue = C.GoString(xc.colo_filter_mirror_queue)
- x.ColoFilterMirrorOutdev = C.GoString(xc.colo_filter_mirror_outdev)
- x.ColoFilterRedirector0Queue = C.GoString(xc.colo_filter_redirector0_queue)
- x.ColoFilterRedirector0Indev = C.GoString(xc.colo_filter_redirector0_indev)
- x.ColoFilterRedirector0Outdev = C.GoString(xc.colo_filter_redirector0_outdev)
- x.ColoFilterRedirector1Queue = C.GoString(xc.colo_filter_redirector1_queue)
- x.ColoFilterRedirector1Indev = C.GoString(xc.colo_filter_redirector1_indev)
- x.ColoFilterRedirector1Outdev = C.GoString(xc.colo_filter_redirector1_outdev)
- x.ColoComparePriIn = C.GoString(xc.colo_compare_pri_in)
- x.ColoCompareSecIn = C.GoString(xc.colo_compare_sec_in)
- x.ColoCompareOut = C.GoString(xc.colo_compare_out)
- x.ColoCompareNotifyDev = C.GoString(xc.colo_compare_notify_dev)
- x.ColoSockSecRedirector0Id = C.GoString(xc.colo_sock_sec_redirector0_id)
- x.ColoSockSecRedirector0Ip = C.GoString(xc.colo_sock_sec_redirector0_ip)
- x.ColoSockSecRedirector0Port = C.GoString(xc.colo_sock_sec_redirector0_port)
- x.ColoSockSecRedirector1Id = C.GoString(xc.colo_sock_sec_redirector1_id)
- x.ColoSockSecRedirector1Ip = C.GoString(xc.colo_sock_sec_redirector1_ip)
- x.ColoSockSecRedirector1Port = C.GoString(xc.colo_sock_sec_redirector1_port)
- x.ColoFilterSecRedirector0Queue = C.GoString(xc.colo_filter_sec_redirector0_queue)
- x.ColoFilterSecRedirector0Indev = C.GoString(xc.colo_filter_sec_redirector0_indev)
- x.ColoFilterSecRedirector0Outdev = C.GoString(xc.colo_filter_sec_redirector0_outdev)
- x.ColoFilterSecRedirector1Queue = C.GoString(xc.colo_filter_sec_redirector1_queue)
- x.ColoFilterSecRedirector1Indev = C.GoString(xc.colo_filter_sec_redirector1_indev)
- x.ColoFilterSecRedirector1Outdev = C.GoString(xc.colo_filter_sec_redirector1_outdev)
- x.ColoFilterSecRewriter0Queue = C.GoString(xc.colo_filter_sec_rewriter0_queue)
- x.ColoCheckpointHost = C.GoString(xc.colo_checkpoint_host)
- x.ColoCheckpointPort = C.GoString(xc.colo_checkpoint_port)
-
- return nil
-}
-
-func (x *DeviceNic) toC(xc *C.libxl_device_nic) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_nic_dispose(xc)
- }
- }()
-
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
- xc.devid = C.libxl_devid(x.Devid)
- xc.mtu = C.int(x.Mtu)
- if x.Model != "" {
- xc.model = C.CString(x.Model)
- }
- if err := x.Mac.toC(&xc.mac); err != nil {
- return fmt.Errorf("converting field Mac: %v", err)
- }
- if x.Ip != "" {
- xc.ip = C.CString(x.Ip)
- }
- if x.Bridge != "" {
- xc.bridge = C.CString(x.Bridge)
- }
- if x.Ifname != "" {
- xc.ifname = C.CString(x.Ifname)
- }
- if x.Script != "" {
- xc.script = C.CString(x.Script)
- }
- xc.nictype = C.libxl_nic_type(x.Nictype)
- xc.rate_bytes_per_interval = C.uint64_t(x.RateBytesPerInterval)
- xc.rate_interval_usecs = C.uint32_t(x.RateIntervalUsecs)
- if x.Gatewaydev != "" {
- xc.gatewaydev = C.CString(x.Gatewaydev)
- }
- if x.ColoftForwarddev != "" {
- xc.coloft_forwarddev = C.CString(x.ColoftForwarddev)
- }
- if x.ColoSockMirrorId != "" {
- xc.colo_sock_mirror_id = C.CString(x.ColoSockMirrorId)
- }
- if x.ColoSockMirrorIp != "" {
- xc.colo_sock_mirror_ip = C.CString(x.ColoSockMirrorIp)
- }
- if x.ColoSockMirrorPort != "" {
- xc.colo_sock_mirror_port = C.CString(x.ColoSockMirrorPort)
- }
- if x.ColoSockComparePriInId != "" {
- xc.colo_sock_compare_pri_in_id = C.CString(x.ColoSockComparePriInId)
- }
- if x.ColoSockComparePriInIp != "" {
- xc.colo_sock_compare_pri_in_ip = C.CString(x.ColoSockComparePriInIp)
- }
- if x.ColoSockComparePriInPort != "" {
- xc.colo_sock_compare_pri_in_port = C.CString(x.ColoSockComparePriInPort)
- }
- if x.ColoSockCompareSecInId != "" {
- xc.colo_sock_compare_sec_in_id = C.CString(x.ColoSockCompareSecInId)
- }
- if x.ColoSockCompareSecInIp != "" {
- xc.colo_sock_compare_sec_in_ip = C.CString(x.ColoSockCompareSecInIp)
- }
- if x.ColoSockCompareSecInPort != "" {
- xc.colo_sock_compare_sec_in_port = C.CString(x.ColoSockCompareSecInPort)
- }
- if x.ColoSockCompareNotifyId != "" {
- xc.colo_sock_compare_notify_id = C.CString(x.ColoSockCompareNotifyId)
- }
- if x.ColoSockCompareNotifyIp != "" {
- xc.colo_sock_compare_notify_ip = C.CString(x.ColoSockCompareNotifyIp)
- }
- if x.ColoSockCompareNotifyPort != "" {
- xc.colo_sock_compare_notify_port = C.CString(x.ColoSockCompareNotifyPort)
- }
- if x.ColoSockRedirector0Id != "" {
- xc.colo_sock_redirector0_id = C.CString(x.ColoSockRedirector0Id)
- }
- if x.ColoSockRedirector0Ip != "" {
- xc.colo_sock_redirector0_ip = C.CString(x.ColoSockRedirector0Ip)
- }
- if x.ColoSockRedirector0Port != "" {
- xc.colo_sock_redirector0_port = C.CString(x.ColoSockRedirector0Port)
- }
- if x.ColoSockRedirector1Id != "" {
- xc.colo_sock_redirector1_id = C.CString(x.ColoSockRedirector1Id)
- }
- if x.ColoSockRedirector1Ip != "" {
- xc.colo_sock_redirector1_ip = C.CString(x.ColoSockRedirector1Ip)
- }
- if x.ColoSockRedirector1Port != "" {
- xc.colo_sock_redirector1_port = C.CString(x.ColoSockRedirector1Port)
- }
- if x.ColoSockRedirector2Id != "" {
- xc.colo_sock_redirector2_id = C.CString(x.ColoSockRedirector2Id)
- }
- if x.ColoSockRedirector2Ip != "" {
- xc.colo_sock_redirector2_ip = C.CString(x.ColoSockRedirector2Ip)
- }
- if x.ColoSockRedirector2Port != "" {
- xc.colo_sock_redirector2_port = C.CString(x.ColoSockRedirector2Port)
- }
- if x.ColoFilterMirrorQueue != "" {
- xc.colo_filter_mirror_queue = C.CString(x.ColoFilterMirrorQueue)
- }
- if x.ColoFilterMirrorOutdev != "" {
- xc.colo_filter_mirror_outdev = C.CString(x.ColoFilterMirrorOutdev)
- }
- if x.ColoFilterRedirector0Queue != "" {
- xc.colo_filter_redirector0_queue = C.CString(x.ColoFilterRedirector0Queue)
- }
- if x.ColoFilterRedirector0Indev != "" {
- xc.colo_filter_redirector0_indev = C.CString(x.ColoFilterRedirector0Indev)
- }
- if x.ColoFilterRedirector0Outdev != "" {
- xc.colo_filter_redirector0_outdev = C.CString(x.ColoFilterRedirector0Outdev)
- }
- if x.ColoFilterRedirector1Queue != "" {
- xc.colo_filter_redirector1_queue = C.CString(x.ColoFilterRedirector1Queue)
- }
- if x.ColoFilterRedirector1Indev != "" {
- xc.colo_filter_redirector1_indev = C.CString(x.ColoFilterRedirector1Indev)
- }
- if x.ColoFilterRedirector1Outdev != "" {
- xc.colo_filter_redirector1_outdev = C.CString(x.ColoFilterRedirector1Outdev)
- }
- if x.ColoComparePriIn != "" {
- xc.colo_compare_pri_in = C.CString(x.ColoComparePriIn)
- }
- if x.ColoCompareSecIn != "" {
- xc.colo_compare_sec_in = C.CString(x.ColoCompareSecIn)
- }
- if x.ColoCompareOut != "" {
- xc.colo_compare_out = C.CString(x.ColoCompareOut)
- }
- if x.ColoCompareNotifyDev != "" {
- xc.colo_compare_notify_dev = C.CString(x.ColoCompareNotifyDev)
- }
- if x.ColoSockSecRedirector0Id != "" {
- xc.colo_sock_sec_redirector0_id = C.CString(x.ColoSockSecRedirector0Id)
- }
- if x.ColoSockSecRedirector0Ip != "" {
- xc.colo_sock_sec_redirector0_ip = C.CString(x.ColoSockSecRedirector0Ip)
- }
- if x.ColoSockSecRedirector0Port != "" {
- xc.colo_sock_sec_redirector0_port = C.CString(x.ColoSockSecRedirector0Port)
- }
- if x.ColoSockSecRedirector1Id != "" {
- xc.colo_sock_sec_redirector1_id = C.CString(x.ColoSockSecRedirector1Id)
- }
- if x.ColoSockSecRedirector1Ip != "" {
- xc.colo_sock_sec_redirector1_ip = C.CString(x.ColoSockSecRedirector1Ip)
- }
- if x.ColoSockSecRedirector1Port != "" {
- xc.colo_sock_sec_redirector1_port = C.CString(x.ColoSockSecRedirector1Port)
- }
- if x.ColoFilterSecRedirector0Queue != "" {
- xc.colo_filter_sec_redirector0_queue = C.CString(x.ColoFilterSecRedirector0Queue)
- }
- if x.ColoFilterSecRedirector0Indev != "" {
- xc.colo_filter_sec_redirector0_indev = C.CString(x.ColoFilterSecRedirector0Indev)
- }
- if x.ColoFilterSecRedirector0Outdev != "" {
- xc.colo_filter_sec_redirector0_outdev = C.CString(x.ColoFilterSecRedirector0Outdev)
- }
- if x.ColoFilterSecRedirector1Queue != "" {
- xc.colo_filter_sec_redirector1_queue = C.CString(x.ColoFilterSecRedirector1Queue)
- }
- if x.ColoFilterSecRedirector1Indev != "" {
- xc.colo_filter_sec_redirector1_indev = C.CString(x.ColoFilterSecRedirector1Indev)
- }
- if x.ColoFilterSecRedirector1Outdev != "" {
- xc.colo_filter_sec_redirector1_outdev = C.CString(x.ColoFilterSecRedirector1Outdev)
- }
- if x.ColoFilterSecRewriter0Queue != "" {
- xc.colo_filter_sec_rewriter0_queue = C.CString(x.ColoFilterSecRewriter0Queue)
- }
- if x.ColoCheckpointHost != "" {
- xc.colo_checkpoint_host = C.CString(x.ColoCheckpointHost)
- }
- if x.ColoCheckpointPort != "" {
- xc.colo_checkpoint_port = C.CString(x.ColoCheckpointPort)
- }
-
- return nil
-}
+ x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+x.Devid = Devid(xc.devid)
+x.Mtu = int(xc.mtu)
+x.Model = C.GoString(xc.model)
+if err := x.Mac.fromC(&xc.mac);err != nil {
+return fmt.Errorf("converting field Mac: %v", err)
+}
+x.Ip = C.GoString(xc.ip)
+x.Bridge = C.GoString(xc.bridge)
+x.Ifname = C.GoString(xc.ifname)
+x.Script = C.GoString(xc.script)
+x.Nictype = NicType(xc.nictype)
+x.RateBytesPerInterval = uint64(xc.rate_bytes_per_interval)
+x.RateIntervalUsecs = uint32(xc.rate_interval_usecs)
+x.Gatewaydev = C.GoString(xc.gatewaydev)
+x.ColoftForwarddev = C.GoString(xc.coloft_forwarddev)
+x.ColoSockMirrorId = C.GoString(xc.colo_sock_mirror_id)
+x.ColoSockMirrorIp = C.GoString(xc.colo_sock_mirror_ip)
+x.ColoSockMirrorPort = C.GoString(xc.colo_sock_mirror_port)
+x.ColoSockComparePriInId = C.GoString(xc.colo_sock_compare_pri_in_id)
+x.ColoSockComparePriInIp = C.GoString(xc.colo_sock_compare_pri_in_ip)
+x.ColoSockComparePriInPort = C.GoString(xc.colo_sock_compare_pri_in_port)
+x.ColoSockCompareSecInId = C.GoString(xc.colo_sock_compare_sec_in_id)
+x.ColoSockCompareSecInIp = C.GoString(xc.colo_sock_compare_sec_in_ip)
+x.ColoSockCompareSecInPort = C.GoString(xc.colo_sock_compare_sec_in_port)
+x.ColoSockCompareNotifyId = C.GoString(xc.colo_sock_compare_notify_id)
+x.ColoSockCompareNotifyIp = C.GoString(xc.colo_sock_compare_notify_ip)
+x.ColoSockCompareNotifyPort = C.GoString(xc.colo_sock_compare_notify_port)
+x.ColoSockRedirector0Id = C.GoString(xc.colo_sock_redirector0_id)
+x.ColoSockRedirector0Ip = C.GoString(xc.colo_sock_redirector0_ip)
+x.ColoSockRedirector0Port = C.GoString(xc.colo_sock_redirector0_port)
+x.ColoSockRedirector1Id = C.GoString(xc.colo_sock_redirector1_id)
+x.ColoSockRedirector1Ip = C.GoString(xc.colo_sock_redirector1_ip)
+x.ColoSockRedirector1Port = C.GoString(xc.colo_sock_redirector1_port)
+x.ColoSockRedirector2Id = C.GoString(xc.colo_sock_redirector2_id)
+x.ColoSockRedirector2Ip = C.GoString(xc.colo_sock_redirector2_ip)
+x.ColoSockRedirector2Port = C.GoString(xc.colo_sock_redirector2_port)
+x.ColoFilterMirrorQueue = C.GoString(xc.colo_filter_mirror_queue)
+x.ColoFilterMirrorOutdev = C.GoString(xc.colo_filter_mirror_outdev)
+x.ColoFilterRedirector0Queue = C.GoString(xc.colo_filter_redirector0_queue)
+x.ColoFilterRedirector0Indev = C.GoString(xc.colo_filter_redirector0_indev)
+x.ColoFilterRedirector0Outdev = C.GoString(xc.colo_filter_redirector0_outdev)
+x.ColoFilterRedirector1Queue = C.GoString(xc.colo_filter_redirector1_queue)
+x.ColoFilterRedirector1Indev = C.GoString(xc.colo_filter_redirector1_indev)
+x.ColoFilterRedirector1Outdev = C.GoString(xc.colo_filter_redirector1_outdev)
+x.ColoComparePriIn = C.GoString(xc.colo_compare_pri_in)
+x.ColoCompareSecIn = C.GoString(xc.colo_compare_sec_in)
+x.ColoCompareOut = C.GoString(xc.colo_compare_out)
+x.ColoCompareNotifyDev = C.GoString(xc.colo_compare_notify_dev)
+x.ColoSockSecRedirector0Id = C.GoString(xc.colo_sock_sec_redirector0_id)
+x.ColoSockSecRedirector0Ip = C.GoString(xc.colo_sock_sec_redirector0_ip)
+x.ColoSockSecRedirector0Port = C.GoString(xc.colo_sock_sec_redirector0_port)
+x.ColoSockSecRedirector1Id = C.GoString(xc.colo_sock_sec_redirector1_id)
+x.ColoSockSecRedirector1Ip = C.GoString(xc.colo_sock_sec_redirector1_ip)
+x.ColoSockSecRedirector1Port = C.GoString(xc.colo_sock_sec_redirector1_port)
+x.ColoFilterSecRedirector0Queue = C.GoString(xc.colo_filter_sec_redirector0_queue)
+x.ColoFilterSecRedirector0Indev = C.GoString(xc.colo_filter_sec_redirector0_indev)
+x.ColoFilterSecRedirector0Outdev = C.GoString(xc.colo_filter_sec_redirector0_outdev)
+x.ColoFilterSecRedirector1Queue = C.GoString(xc.colo_filter_sec_redirector1_queue)
+x.ColoFilterSecRedirector1Indev = C.GoString(xc.colo_filter_sec_redirector1_indev)
+x.ColoFilterSecRedirector1Outdev = C.GoString(xc.colo_filter_sec_redirector1_outdev)
+x.ColoFilterSecRewriter0Queue = C.GoString(xc.colo_filter_sec_rewriter0_queue)
+x.ColoCheckpointHost = C.GoString(xc.colo_checkpoint_host)
+x.ColoCheckpointPort = C.GoString(xc.colo_checkpoint_port)
+
+ return nil}
+
+func (x *DeviceNic) toC(xc *C.libxl_device_nic) (err error){defer func(){
+if err != nil{
+C.libxl_device_nic_dispose(xc)}
+}()
+
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+xc.devid = C.libxl_devid(x.Devid)
+xc.mtu = C.int(x.Mtu)
+if x.Model != "" {
+xc.model = C.CString(x.Model)}
+if err := x.Mac.toC(&xc.mac); err != nil {
+return fmt.Errorf("converting field Mac: %v", err)
+}
+if x.Ip != "" {
+xc.ip = C.CString(x.Ip)}
+if x.Bridge != "" {
+xc.bridge = C.CString(x.Bridge)}
+if x.Ifname != "" {
+xc.ifname = C.CString(x.Ifname)}
+if x.Script != "" {
+xc.script = C.CString(x.Script)}
+xc.nictype = C.libxl_nic_type(x.Nictype)
+xc.rate_bytes_per_interval = C.uint64_t(x.RateBytesPerInterval)
+xc.rate_interval_usecs = C.uint32_t(x.RateIntervalUsecs)
+if x.Gatewaydev != "" {
+xc.gatewaydev = C.CString(x.Gatewaydev)}
+if x.ColoftForwarddev != "" {
+xc.coloft_forwarddev = C.CString(x.ColoftForwarddev)}
+if x.ColoSockMirrorId != "" {
+xc.colo_sock_mirror_id = C.CString(x.ColoSockMirrorId)}
+if x.ColoSockMirrorIp != "" {
+xc.colo_sock_mirror_ip = C.CString(x.ColoSockMirrorIp)}
+if x.ColoSockMirrorPort != "" {
+xc.colo_sock_mirror_port = C.CString(x.ColoSockMirrorPort)}
+if x.ColoSockComparePriInId != "" {
+xc.colo_sock_compare_pri_in_id = C.CString(x.ColoSockComparePriInId)}
+if x.ColoSockComparePriInIp != "" {
+xc.colo_sock_compare_pri_in_ip = C.CString(x.ColoSockComparePriInIp)}
+if x.ColoSockComparePriInPort != "" {
+xc.colo_sock_compare_pri_in_port = C.CString(x.ColoSockComparePriInPort)}
+if x.ColoSockCompareSecInId != "" {
+xc.colo_sock_compare_sec_in_id = C.CString(x.ColoSockCompareSecInId)}
+if x.ColoSockCompareSecInIp != "" {
+xc.colo_sock_compare_sec_in_ip = C.CString(x.ColoSockCompareSecInIp)}
+if x.ColoSockCompareSecInPort != "" {
+xc.colo_sock_compare_sec_in_port = C.CString(x.ColoSockCompareSecInPort)}
+if x.ColoSockCompareNotifyId != "" {
+xc.colo_sock_compare_notify_id = C.CString(x.ColoSockCompareNotifyId)}
+if x.ColoSockCompareNotifyIp != "" {
+xc.colo_sock_compare_notify_ip = C.CString(x.ColoSockCompareNotifyIp)}
+if x.ColoSockCompareNotifyPort != "" {
+xc.colo_sock_compare_notify_port = C.CString(x.ColoSockCompareNotifyPort)}
+if x.ColoSockRedirector0Id != "" {
+xc.colo_sock_redirector0_id = C.CString(x.ColoSockRedirector0Id)}
+if x.ColoSockRedirector0Ip != "" {
+xc.colo_sock_redirector0_ip = C.CString(x.ColoSockRedirector0Ip)}
+if x.ColoSockRedirector0Port != "" {
+xc.colo_sock_redirector0_port = C.CString(x.ColoSockRedirector0Port)}
+if x.ColoSockRedirector1Id != "" {
+xc.colo_sock_redirector1_id = C.CString(x.ColoSockRedirector1Id)}
+if x.ColoSockRedirector1Ip != "" {
+xc.colo_sock_redirector1_ip = C.CString(x.ColoSockRedirector1Ip)}
+if x.ColoSockRedirector1Port != "" {
+xc.colo_sock_redirector1_port = C.CString(x.ColoSockRedirector1Port)}
+if x.ColoSockRedirector2Id != "" {
+xc.colo_sock_redirector2_id = C.CString(x.ColoSockRedirector2Id)}
+if x.ColoSockRedirector2Ip != "" {
+xc.colo_sock_redirector2_ip = C.CString(x.ColoSockRedirector2Ip)}
+if x.ColoSockRedirector2Port != "" {
+xc.colo_sock_redirector2_port = C.CString(x.ColoSockRedirector2Port)}
+if x.ColoFilterMirrorQueue != "" {
+xc.colo_filter_mirror_queue = C.CString(x.ColoFilterMirrorQueue)}
+if x.ColoFilterMirrorOutdev != "" {
+xc.colo_filter_mirror_outdev = C.CString(x.ColoFilterMirrorOutdev)}
+if x.ColoFilterRedirector0Queue != "" {
+xc.colo_filter_redirector0_queue = C.CString(x.ColoFilterRedirector0Queue)}
+if x.ColoFilterRedirector0Indev != "" {
+xc.colo_filter_redirector0_indev = C.CString(x.ColoFilterRedirector0Indev)}
+if x.ColoFilterRedirector0Outdev != "" {
+xc.colo_filter_redirector0_outdev = C.CString(x.ColoFilterRedirector0Outdev)}
+if x.ColoFilterRedirector1Queue != "" {
+xc.colo_filter_redirector1_queue = C.CString(x.ColoFilterRedirector1Queue)}
+if x.ColoFilterRedirector1Indev != "" {
+xc.colo_filter_redirector1_indev = C.CString(x.ColoFilterRedirector1Indev)}
+if x.ColoFilterRedirector1Outdev != "" {
+xc.colo_filter_redirector1_outdev = C.CString(x.ColoFilterRedirector1Outdev)}
+if x.ColoComparePriIn != "" {
+xc.colo_compare_pri_in = C.CString(x.ColoComparePriIn)}
+if x.ColoCompareSecIn != "" {
+xc.colo_compare_sec_in = C.CString(x.ColoCompareSecIn)}
+if x.ColoCompareOut != "" {
+xc.colo_compare_out = C.CString(x.ColoCompareOut)}
+if x.ColoCompareNotifyDev != "" {
+xc.colo_compare_notify_dev = C.CString(x.ColoCompareNotifyDev)}
+if x.ColoSockSecRedirector0Id != "" {
+xc.colo_sock_sec_redirector0_id = C.CString(x.ColoSockSecRedirector0Id)}
+if x.ColoSockSecRedirector0Ip != "" {
+xc.colo_sock_sec_redirector0_ip = C.CString(x.ColoSockSecRedirector0Ip)}
+if x.ColoSockSecRedirector0Port != "" {
+xc.colo_sock_sec_redirector0_port = C.CString(x.ColoSockSecRedirector0Port)}
+if x.ColoSockSecRedirector1Id != "" {
+xc.colo_sock_sec_redirector1_id = C.CString(x.ColoSockSecRedirector1Id)}
+if x.ColoSockSecRedirector1Ip != "" {
+xc.colo_sock_sec_redirector1_ip = C.CString(x.ColoSockSecRedirector1Ip)}
+if x.ColoSockSecRedirector1Port != "" {
+xc.colo_sock_sec_redirector1_port = C.CString(x.ColoSockSecRedirector1Port)}
+if x.ColoFilterSecRedirector0Queue != "" {
+xc.colo_filter_sec_redirector0_queue = C.CString(x.ColoFilterSecRedirector0Queue)}
+if x.ColoFilterSecRedirector0Indev != "" {
+xc.colo_filter_sec_redirector0_indev = C.CString(x.ColoFilterSecRedirector0Indev)}
+if x.ColoFilterSecRedirector0Outdev != "" {
+xc.colo_filter_sec_redirector0_outdev = C.CString(x.ColoFilterSecRedirector0Outdev)}
+if x.ColoFilterSecRedirector1Queue != "" {
+xc.colo_filter_sec_redirector1_queue = C.CString(x.ColoFilterSecRedirector1Queue)}
+if x.ColoFilterSecRedirector1Indev != "" {
+xc.colo_filter_sec_redirector1_indev = C.CString(x.ColoFilterSecRedirector1Indev)}
+if x.ColoFilterSecRedirector1Outdev != "" {
+xc.colo_filter_sec_redirector1_outdev = C.CString(x.ColoFilterSecRedirector1Outdev)}
+if x.ColoFilterSecRewriter0Queue != "" {
+xc.colo_filter_sec_rewriter0_queue = C.CString(x.ColoFilterSecRewriter0Queue)}
+if x.ColoCheckpointHost != "" {
+xc.colo_checkpoint_host = C.CString(x.ColoCheckpointHost)}
+if x.ColoCheckpointPort != "" {
+xc.colo_checkpoint_port = C.CString(x.ColoCheckpointPort)}
+
+ return nil
+ }
// NewDevicePci returns an instance of DevicePci initialized with defaults.
func NewDevicePci() (*DevicePci, error) {
- var (
- x DevicePci
- xc C.libxl_device_pci
- )
+var (
+x DevicePci
+xc C.libxl_device_pci)
- C.libxl_device_pci_init(&xc)
- defer C.libxl_device_pci_dispose(&xc)
+C.libxl_device_pci_init(&xc)
+defer C.libxl_device_pci_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DevicePci) fromC(xc *C.libxl_device_pci) error {
- x.Func = byte(xc._func)
- x.Dev = byte(xc.dev)
- x.Bus = byte(xc.bus)
- x.Domain = int(xc.domain)
- x.Vdevfn = uint32(xc.vdevfn)
- x.VfuncMask = uint32(xc.vfunc_mask)
- x.Msitranslate = bool(xc.msitranslate)
- x.PowerMgmt = bool(xc.power_mgmt)
- x.Permissive = bool(xc.permissive)
- x.Seize = bool(xc.seize)
- x.RdmPolicy = RdmReservePolicy(xc.rdm_policy)
-
- return nil
-}
-
-func (x *DevicePci) toC(xc *C.libxl_device_pci) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_pci_dispose(xc)
- }
- }()
-
- xc._func = C.uint8_t(x.Func)
- xc.dev = C.uint8_t(x.Dev)
- xc.bus = C.uint8_t(x.Bus)
- xc.domain = C.int(x.Domain)
- xc.vdevfn = C.uint32_t(x.Vdevfn)
- xc.vfunc_mask = C.uint32_t(x.VfuncMask)
- xc.msitranslate = C.bool(x.Msitranslate)
- xc.power_mgmt = C.bool(x.PowerMgmt)
- xc.permissive = C.bool(x.Permissive)
- xc.seize = C.bool(x.Seize)
- xc.rdm_policy = C.libxl_rdm_reserve_policy(x.RdmPolicy)
-
- return nil
-}
+ x.Func = byte(xc._func)
+x.Dev = byte(xc.dev)
+x.Bus = byte(xc.bus)
+x.Domain = int(xc.domain)
+x.Vdevfn = uint32(xc.vdevfn)
+x.VfuncMask = uint32(xc.vfunc_mask)
+x.Msitranslate = bool(xc.msitranslate)
+x.PowerMgmt = bool(xc.power_mgmt)
+x.Permissive = bool(xc.permissive)
+x.Seize = bool(xc.seize)
+x.RdmPolicy = RdmReservePolicy(xc.rdm_policy)
+
+ return nil}
+
+func (x *DevicePci) toC(xc *C.libxl_device_pci) (err error){defer func(){
+if err != nil{
+C.libxl_device_pci_dispose(xc)}
+}()
+
+xc._func = C.uint8_t(x.Func)
+xc.dev = C.uint8_t(x.Dev)
+xc.bus = C.uint8_t(x.Bus)
+xc.domain = C.int(x.Domain)
+xc.vdevfn = C.uint32_t(x.Vdevfn)
+xc.vfunc_mask = C.uint32_t(x.VfuncMask)
+xc.msitranslate = C.bool(x.Msitranslate)
+xc.power_mgmt = C.bool(x.PowerMgmt)
+xc.permissive = C.bool(x.Permissive)
+xc.seize = C.bool(x.Seize)
+xc.rdm_policy = C.libxl_rdm_reserve_policy(x.RdmPolicy)
+
+ return nil
+ }
// NewDeviceRdm returns an instance of DeviceRdm initialized with defaults.
func NewDeviceRdm() (*DeviceRdm, error) {
- var (
- x DeviceRdm
- xc C.libxl_device_rdm
- )
+var (
+x DeviceRdm
+xc C.libxl_device_rdm)
- C.libxl_device_rdm_init(&xc)
- defer C.libxl_device_rdm_dispose(&xc)
+C.libxl_device_rdm_init(&xc)
+defer C.libxl_device_rdm_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) error {
- x.Start = uint64(xc.start)
- x.Size = uint64(xc.size)
- x.Policy = RdmReservePolicy(xc.policy)
+ x.Start = uint64(xc.start)
+x.Size = uint64(xc.size)
+x.Policy = RdmReservePolicy(xc.policy)
- return nil
-}
+ return nil}
-func (x *DeviceRdm) toC(xc *C.libxl_device_rdm) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_rdm_dispose(xc)
- }
- }()
+func (x *DeviceRdm) toC(xc *C.libxl_device_rdm) (err error){defer func(){
+if err != nil{
+C.libxl_device_rdm_dispose(xc)}
+}()
- xc.start = C.uint64_t(x.Start)
- xc.size = C.uint64_t(x.Size)
- xc.policy = C.libxl_rdm_reserve_policy(x.Policy)
+xc.start = C.uint64_t(x.Start)
+xc.size = C.uint64_t(x.Size)
+xc.policy = C.libxl_rdm_reserve_policy(x.Policy)
- return nil
-}
+ return nil
+ }
// NewDeviceUsbctrl returns an instance of DeviceUsbctrl initialized with defaults.
func NewDeviceUsbctrl() (*DeviceUsbctrl, error) {
- var (
- x DeviceUsbctrl
- xc C.libxl_device_usbctrl
- )
+var (
+x DeviceUsbctrl
+xc C.libxl_device_usbctrl)
- C.libxl_device_usbctrl_init(&xc)
- defer C.libxl_device_usbctrl_dispose(&xc)
+C.libxl_device_usbctrl_init(&xc)
+defer C.libxl_device_usbctrl_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error {
- x.Type = UsbctrlType(xc._type)
- x.Devid = Devid(xc.devid)
- x.Version = int(xc.version)
- x.Ports = int(xc.ports)
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
-
- return nil
-}
-
-func (x *DeviceUsbctrl) toC(xc *C.libxl_device_usbctrl) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_usbctrl_dispose(xc)
- }
- }()
-
- xc._type = C.libxl_usbctrl_type(x.Type)
- xc.devid = C.libxl_devid(x.Devid)
- xc.version = C.int(x.Version)
- xc.ports = C.int(x.Ports)
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
-
- return nil
-}
+ x.Type = UsbctrlType(xc._type)
+x.Devid = Devid(xc.devid)
+x.Version = int(xc.version)
+x.Ports = int(xc.ports)
+x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+
+ return nil}
+
+func (x *DeviceUsbctrl) toC(xc *C.libxl_device_usbctrl) (err error){defer func(){
+if err != nil{
+C.libxl_device_usbctrl_dispose(xc)}
+}()
+
+xc._type = C.libxl_usbctrl_type(x.Type)
+xc.devid = C.libxl_devid(x.Devid)
+xc.version = C.int(x.Version)
+xc.ports = C.int(x.Ports)
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+
+ return nil
+ }
// NewDeviceUsbdev returns an instance of DeviceUsbdev initialized with defaults.
func NewDeviceUsbdev(utype UsbdevType) (*DeviceUsbdev, error) {
- var (
- x DeviceUsbdev
- xc C.libxl_device_usbdev
- )
+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)
+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 := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceUsbdev) fromC(xc *C.libxl_device_usbdev) error {
- x.Ctrl = Devid(xc.ctrl)
- x.Port = int(xc.port)
- x.Type = UsbdevType(xc._type)
- switch x.Type {
- case UsbdevTypeHostdev:
- var typeHostdev DeviceUsbdevTypeUnionHostdev
- if err := typeHostdev.fromC(xc); err != nil {
- return fmt.Errorf("converting field typeHostdev: %v", err)
- }
- x.TypeUnion = typeHostdev
- default:
- return fmt.Errorf("invalid union key '%v'", x.Type)
- }
-
- return nil
+ x.Ctrl = Devid(xc.ctrl)
+x.Port = int(xc.port)
+x.Type = UsbdevType(xc._type)
+switch x.Type{
+case UsbdevTypeHostdev:
+var typeHostdev DeviceUsbdevTypeUnionHostdev
+if err := typeHostdev.fromC(xc);err != nil {
+ return fmt.Errorf("converting field typeHostdev: %v", err)
}
+x.TypeUnion = typeHostdev
+default:
+return fmt.Errorf("invalid union key '%v'", x.Type)}
+
+ return nil}
func (x *DeviceUsbdevTypeUnionHostdev) fromC(xc *C.libxl_device_usbdev) error {
- if UsbdevType(xc._type) != UsbdevTypeHostdev {
- return errors.New("expected union key UsbdevTypeHostdev")
- }
-
- tmp := (*C.libxl_device_usbdev_type_union_hostdev)(unsafe.Pointer(&xc.u[0]))
- x.Hostbus = byte(tmp.hostbus)
- x.Hostaddr = byte(tmp.hostaddr)
- return nil
-}
-
-func (x *DeviceUsbdev) toC(xc *C.libxl_device_usbdev) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_usbdev_dispose(xc)
- }
- }()
-
- xc.ctrl = C.libxl_devid(x.Ctrl)
- xc.port = C.int(x.Port)
- xc._type = C.libxl_usbdev_type(x.Type)
- switch x.Type {
- case UsbdevTypeHostdev:
- tmp, ok := x.TypeUnion.(DeviceUsbdevTypeUnionHostdev)
- if !ok {
- return errors.New("wrong type for union key type")
- }
- var hostdev C.libxl_device_usbdev_type_union_hostdev
- hostdev.hostbus = C.uint8_t(tmp.Hostbus)
- hostdev.hostaddr = C.uint8_t(tmp.Hostaddr)
- hostdevBytes := C.GoBytes(unsafe.Pointer(&hostdev), C.sizeof_libxl_device_usbdev_type_union_hostdev)
- copy(xc.u[:], hostdevBytes)
- default:
- return fmt.Errorf("invalid union key '%v'", x.Type)
- }
-
- return nil
+if UsbdevType(xc._type) != UsbdevTypeHostdev {
+return errors.New("expected union key UsbdevTypeHostdev")
}
+tmp := (*C.libxl_device_usbdev_type_union_hostdev)(unsafe.Pointer(&xc.u[0]))
+x.Hostbus = byte(tmp.hostbus)
+x.Hostaddr = byte(tmp.hostaddr)
+return nil
+}
+
+func (x *DeviceUsbdev) toC(xc *C.libxl_device_usbdev) (err error){defer func(){
+if err != nil{
+C.libxl_device_usbdev_dispose(xc)}
+}()
+
+xc.ctrl = C.libxl_devid(x.Ctrl)
+xc.port = C.int(x.Port)
+xc._type = C.libxl_usbdev_type(x.Type)
+switch x.Type{
+case UsbdevTypeHostdev:
+tmp, ok := x.TypeUnion.(DeviceUsbdevTypeUnionHostdev)
+if !ok {
+return errors.New("wrong type for union key type")
+}
+var hostdev C.libxl_device_usbdev_type_union_hostdev
+hostdev.hostbus = C.uint8_t(tmp.Hostbus)
+hostdev.hostaddr = C.uint8_t(tmp.Hostaddr)
+hostdevBytes := C.GoBytes(unsafe.Pointer(&hostdev),C.sizeof_libxl_device_usbdev_type_union_hostdev)
+copy(xc.u[:],hostdevBytes)
+default:
+return fmt.Errorf("invalid union key '%v'", x.Type)}
+
+ return nil
+ }
+
// NewDeviceDtdev returns an instance of DeviceDtdev initialized with defaults.
func NewDeviceDtdev() (*DeviceDtdev, error) {
- var (
- x DeviceDtdev
- xc C.libxl_device_dtdev
- )
+var (
+x DeviceDtdev
+xc C.libxl_device_dtdev)
- C.libxl_device_dtdev_init(&xc)
- defer C.libxl_device_dtdev_dispose(&xc)
+C.libxl_device_dtdev_init(&xc)
+defer C.libxl_device_dtdev_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceDtdev) fromC(xc *C.libxl_device_dtdev) error {
- x.Path = C.GoString(xc.path)
+ x.Path = C.GoString(xc.path)
- return nil
-}
+ return nil}
-func (x *DeviceDtdev) toC(xc *C.libxl_device_dtdev) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_dtdev_dispose(xc)
- }
- }()
+func (x *DeviceDtdev) toC(xc *C.libxl_device_dtdev) (err error){defer func(){
+if err != nil{
+C.libxl_device_dtdev_dispose(xc)}
+}()
- if x.Path != "" {
- xc.path = C.CString(x.Path)
- }
+if x.Path != "" {
+xc.path = C.CString(x.Path)}
- return nil
-}
+ return nil
+ }
// NewDeviceVtpm returns an instance of DeviceVtpm initialized with defaults.
func NewDeviceVtpm() (*DeviceVtpm, error) {
- var (
- x DeviceVtpm
- xc C.libxl_device_vtpm
- )
+var (
+x DeviceVtpm
+xc C.libxl_device_vtpm)
- C.libxl_device_vtpm_init(&xc)
- defer C.libxl_device_vtpm_dispose(&xc)
+C.libxl_device_vtpm_init(&xc)
+defer C.libxl_device_vtpm_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceVtpm) fromC(xc *C.libxl_device_vtpm) error {
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
- x.Devid = Devid(xc.devid)
- if err := x.Uuid.fromC(&xc.uuid); err != nil {
- return fmt.Errorf("converting field Uuid: %v", err)
- }
-
- return nil
+ x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+x.Devid = Devid(xc.devid)
+if err := x.Uuid.fromC(&xc.uuid);err != nil {
+return fmt.Errorf("converting field Uuid: %v", err)
}
-func (x *DeviceVtpm) toC(xc *C.libxl_device_vtpm) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_vtpm_dispose(xc)
- }
- }()
+ return nil}
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
- xc.devid = C.libxl_devid(x.Devid)
- if err := x.Uuid.toC(&xc.uuid); err != nil {
- return fmt.Errorf("converting field Uuid: %v", err)
- }
+func (x *DeviceVtpm) toC(xc *C.libxl_device_vtpm) (err error){defer func(){
+if err != nil{
+C.libxl_device_vtpm_dispose(xc)}
+}()
- return nil
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+xc.devid = C.libxl_devid(x.Devid)
+if err := x.Uuid.toC(&xc.uuid); err != nil {
+return fmt.Errorf("converting field Uuid: %v", err)
}
+ return nil
+ }
+
// NewDeviceP9 returns an instance of DeviceP9 initialized with defaults.
func NewDeviceP9() (*DeviceP9, error) {
- var (
- x DeviceP9
- xc C.libxl_device_p9
- )
+var (
+x DeviceP9
+xc C.libxl_device_p9)
- C.libxl_device_p9_init(&xc)
- defer C.libxl_device_p9_dispose(&xc)
+C.libxl_device_p9_init(&xc)
+defer C.libxl_device_p9_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error {
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
- x.Tag = C.GoString(xc.tag)
- x.Path = C.GoString(xc.path)
- x.SecurityModel = C.GoString(xc.security_model)
- x.Devid = Devid(xc.devid)
-
- return nil
-}
-
-func (x *DeviceP9) toC(xc *C.libxl_device_p9) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_p9_dispose(xc)
- }
- }()
-
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
- if x.Tag != "" {
- xc.tag = C.CString(x.Tag)
- }
- if x.Path != "" {
- xc.path = C.CString(x.Path)
- }
- if x.SecurityModel != "" {
- xc.security_model = C.CString(x.SecurityModel)
- }
- xc.devid = C.libxl_devid(x.Devid)
-
- return nil
-}
+ x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+x.Tag = C.GoString(xc.tag)
+x.Path = C.GoString(xc.path)
+x.SecurityModel = C.GoString(xc.security_model)
+x.Devid = Devid(xc.devid)
+
+ return nil}
+
+func (x *DeviceP9) toC(xc *C.libxl_device_p9) (err error){defer func(){
+if err != nil{
+C.libxl_device_p9_dispose(xc)}
+}()
+
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+if x.Tag != "" {
+xc.tag = C.CString(x.Tag)}
+if x.Path != "" {
+xc.path = C.CString(x.Path)}
+if x.SecurityModel != "" {
+xc.security_model = C.CString(x.SecurityModel)}
+xc.devid = C.libxl_devid(x.Devid)
+
+ return nil
+ }
// NewDevicePvcallsif returns an instance of DevicePvcallsif initialized with defaults.
func NewDevicePvcallsif() (*DevicePvcallsif, error) {
- var (
- x DevicePvcallsif
- xc C.libxl_device_pvcallsif
- )
+var (
+x DevicePvcallsif
+xc C.libxl_device_pvcallsif)
- C.libxl_device_pvcallsif_init(&xc)
- defer C.libxl_device_pvcallsif_dispose(&xc)
+C.libxl_device_pvcallsif_init(&xc)
+defer C.libxl_device_pvcallsif_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DevicePvcallsif) fromC(xc *C.libxl_device_pvcallsif) error {
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
- x.Devid = Devid(xc.devid)
+ x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+x.Devid = Devid(xc.devid)
- return nil
-}
+ return nil}
-func (x *DevicePvcallsif) toC(xc *C.libxl_device_pvcallsif) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_pvcallsif_dispose(xc)
- }
- }()
+func (x *DevicePvcallsif) toC(xc *C.libxl_device_pvcallsif) (err error){defer func(){
+if err != nil{
+C.libxl_device_pvcallsif_dispose(xc)}
+}()
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
- xc.devid = C.libxl_devid(x.Devid)
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+xc.devid = C.libxl_devid(x.Devid)
- return nil
-}
+ return nil
+ }
// NewDeviceChannel returns an instance of DeviceChannel initialized with defaults.
func NewDeviceChannel(connection ChannelConnection) (*DeviceChannel, error) {
- var (
- x DeviceChannel
- xc C.libxl_device_channel
- )
+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(connection))
- defer C.libxl_device_channel_dispose(&xc)
+C.libxl_device_channel_init(&xc)
+C.libxl_device_channel_init_connection(&xc, C.libxl_channel_connection(connection))
+defer C.libxl_device_channel_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceChannel) fromC(xc *C.libxl_device_channel) error {
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
- x.Devid = Devid(xc.devid)
- x.Name = C.GoString(xc.name)
- x.Connection = ChannelConnection(xc.connection)
- switch x.Connection {
- case ChannelConnectionUnknown:
- x.ConnectionUnion = nil
- case ChannelConnectionPty:
- x.ConnectionUnion = nil
- case ChannelConnectionSocket:
- var connectionSocket DeviceChannelConnectionUnionSocket
- if err := connectionSocket.fromC(xc); err != nil {
- return fmt.Errorf("converting field connectionSocket: %v", err)
- }
- x.ConnectionUnion = connectionSocket
- default:
- return fmt.Errorf("invalid union key '%v'", x.Connection)
- }
-
- return nil
-}
+ x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+x.Devid = Devid(xc.devid)
+x.Name = C.GoString(xc.name)
+x.Connection = ChannelConnection(xc.connection)
+switch x.Connection{
+case ChannelConnectionUnknown:
+x.ConnectionUnion = nil
+case ChannelConnectionPty:
+x.ConnectionUnion = nil
+case ChannelConnectionSocket:
+var connectionSocket DeviceChannelConnectionUnionSocket
+if err := connectionSocket.fromC(xc);err != nil {
+ return fmt.Errorf("converting field connectionSocket: %v", err)
+}
+x.ConnectionUnion = connectionSocket
+default:
+return fmt.Errorf("invalid union key '%v'", x.Connection)}
+
+ return nil}
func (x *DeviceChannelConnectionUnionSocket) fromC(xc *C.libxl_device_channel) error {
- if ChannelConnection(xc.connection) != ChannelConnectionSocket {
- return errors.New("expected union key ChannelConnectionSocket")
- }
-
- tmp := (*C.libxl_device_channel_connection_union_socket)(unsafe.Pointer(&xc.u[0]))
- x.Path = C.GoString(tmp.path)
- return nil
-}
-
-func (x *DeviceChannel) toC(xc *C.libxl_device_channel) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_channel_dispose(xc)
- }
- }()
-
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
- xc.devid = C.libxl_devid(x.Devid)
- if x.Name != "" {
- xc.name = C.CString(x.Name)
- }
- xc.connection = C.libxl_channel_connection(x.Connection)
- switch x.Connection {
- case ChannelConnectionUnknown:
- break
- case ChannelConnectionPty:
- break
- case ChannelConnectionSocket:
- tmp, ok := x.ConnectionUnion.(DeviceChannelConnectionUnionSocket)
- if !ok {
- return errors.New("wrong type for union key connection")
- }
- var socket C.libxl_device_channel_connection_union_socket
- if tmp.Path != "" {
- socket.path = C.CString(tmp.Path)
- }
- socketBytes := C.GoBytes(unsafe.Pointer(&socket), C.sizeof_libxl_device_channel_connection_union_socket)
- copy(xc.u[:], socketBytes)
- default:
- return fmt.Errorf("invalid union key '%v'", x.Connection)
- }
-
- return nil
-}
+if ChannelConnection(xc.connection) != ChannelConnectionSocket {
+return errors.New("expected union key ChannelConnectionSocket")
+}
+
+tmp := (*C.libxl_device_channel_connection_union_socket)(unsafe.Pointer(&xc.u[0]))
+x.Path = C.GoString(tmp.path)
+return nil
+}
+
+func (x *DeviceChannel) toC(xc *C.libxl_device_channel) (err error){defer func(){
+if err != nil{
+C.libxl_device_channel_dispose(xc)}
+}()
+
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+xc.devid = C.libxl_devid(x.Devid)
+if x.Name != "" {
+xc.name = C.CString(x.Name)}
+xc.connection = C.libxl_channel_connection(x.Connection)
+switch x.Connection{
+case ChannelConnectionUnknown:
+break
+case ChannelConnectionPty:
+break
+case ChannelConnectionSocket:
+tmp, ok := x.ConnectionUnion.(DeviceChannelConnectionUnionSocket)
+if !ok {
+return errors.New("wrong type for union key connection")
+}
+var socket C.libxl_device_channel_connection_union_socket
+if tmp.Path != "" {
+socket.path = C.CString(tmp.Path)}
+socketBytes := C.GoBytes(unsafe.Pointer(&socket),C.sizeof_libxl_device_channel_connection_union_socket)
+copy(xc.u[:],socketBytes)
+default:
+return fmt.Errorf("invalid union key '%v'", x.Connection)}
+
+ return nil
+ }
// NewConnectorParam returns an instance of ConnectorParam initialized with defaults.
func NewConnectorParam() (*ConnectorParam, error) {
- var (
- x ConnectorParam
- xc C.libxl_connector_param
- )
+var (
+x ConnectorParam
+xc C.libxl_connector_param)
- C.libxl_connector_param_init(&xc)
- defer C.libxl_connector_param_dispose(&xc)
+C.libxl_connector_param_init(&xc)
+defer C.libxl_connector_param_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *ConnectorParam) fromC(xc *C.libxl_connector_param) error {
- x.UniqueId = C.GoString(xc.unique_id)
- x.Width = uint32(xc.width)
- x.Height = uint32(xc.height)
+ x.UniqueId = C.GoString(xc.unique_id)
+x.Width = uint32(xc.width)
+x.Height = uint32(xc.height)
- return nil
-}
+ return nil}
-func (x *ConnectorParam) toC(xc *C.libxl_connector_param) (err error) {
- defer func() {
- if err != nil {
- C.libxl_connector_param_dispose(xc)
- }
- }()
+func (x *ConnectorParam) toC(xc *C.libxl_connector_param) (err error){defer func(){
+if err != nil{
+C.libxl_connector_param_dispose(xc)}
+}()
- if x.UniqueId != "" {
- xc.unique_id = C.CString(x.UniqueId)
- }
- xc.width = C.uint32_t(x.Width)
- xc.height = C.uint32_t(x.Height)
+if x.UniqueId != "" {
+xc.unique_id = C.CString(x.UniqueId)}
+xc.width = C.uint32_t(x.Width)
+xc.height = C.uint32_t(x.Height)
- return nil
-}
+ return nil
+ }
// NewDeviceVdispl returns an instance of DeviceVdispl initialized with defaults.
func NewDeviceVdispl() (*DeviceVdispl, error) {
- var (
- x DeviceVdispl
- xc C.libxl_device_vdispl
- )
+var (
+x DeviceVdispl
+xc C.libxl_device_vdispl)
- C.libxl_device_vdispl_init(&xc)
- defer C.libxl_device_vdispl_dispose(&xc)
+C.libxl_device_vdispl_init(&xc)
+defer C.libxl_device_vdispl_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdispl) error {
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
- x.Devid = Devid(xc.devid)
- x.BeAlloc = bool(xc.be_alloc)
- x.Connectors = nil
- if n := int(xc.num_connectors); n > 0 {
- cConnectors := (*[1 << 28]C.libxl_connector_param)(unsafe.Pointer(xc.connectors))[:n:n]
- x.Connectors = make([]ConnectorParam, n)
- for i, v := range cConnectors {
- if err := x.Connectors[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Connectors: %v", err)
- }
- }
- }
-
- return nil
-}
-
-func (x *DeviceVdispl) toC(xc *C.libxl_device_vdispl) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_vdispl_dispose(xc)
- }
- }()
-
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
- xc.devid = C.libxl_devid(x.Devid)
- xc.be_alloc = C.bool(x.BeAlloc)
- if numConnectors := len(x.Connectors); numConnectors > 0 {
- xc.connectors = (*C.libxl_connector_param)(C.malloc(C.ulong(numConnectors) * C.sizeof_libxl_connector_param))
- xc.num_connectors = C.int(numConnectors)
- cConnectors := (*[1 << 28]C.libxl_connector_param)(unsafe.Pointer(xc.connectors))[:numConnectors:numConnectors]
- for i, v := range x.Connectors {
- if err := v.toC(&cConnectors[i]); err != nil {
- return fmt.Errorf("converting field Connectors: %v", err)
- }
- }
- }
-
- return nil
+ x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+x.Devid = Devid(xc.devid)
+x.BeAlloc = bool(xc.be_alloc)
+x.Connectors = nil
+if n := int(xc.num_connectors); n > 0 {
+cConnectors := (*[1<<28]C.libxl_connector_param)(unsafe.Pointer(xc.connectors))[:n:n]
+x.Connectors = make([]ConnectorParam, n)
+for i, v := range cConnectors {
+if err := x.Connectors[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Connectors: %v", err) }
+}
}
+ return nil}
+
+func (x *DeviceVdispl) toC(xc *C.libxl_device_vdispl) (err error){defer func(){
+if err != nil{
+C.libxl_device_vdispl_dispose(xc)}
+}()
+
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+xc.devid = C.libxl_devid(x.Devid)
+xc.be_alloc = C.bool(x.BeAlloc)
+if numConnectors := len(x.Connectors); numConnectors > 0 {
+xc.connectors = (*C.libxl_connector_param)(C.malloc(C.ulong(numConnectors)*C.sizeof_libxl_connector_param))
+xc.num_connectors = C.int(numConnectors)
+cConnectors := (*[1<<28]C.libxl_connector_param)(unsafe.Pointer(xc.connectors))[:numConnectors:numConnectors]
+for i,v := range x.Connectors {
+if err := v.toC(&cConnectors[i]); err != nil {
+return fmt.Errorf("converting field Connectors: %v", err)
+}
+}
+}
+
+ return nil
+ }
+
// NewVsndParams returns an instance of VsndParams initialized with defaults.
func NewVsndParams() (*VsndParams, error) {
- var (
- x VsndParams
- xc C.libxl_vsnd_params
- )
+var (
+x VsndParams
+xc C.libxl_vsnd_params)
- C.libxl_vsnd_params_init(&xc)
- defer C.libxl_vsnd_params_dispose(&xc)
+C.libxl_vsnd_params_init(&xc)
+defer C.libxl_vsnd_params_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error {
- x.SampleRates = nil
- if n := int(xc.num_sample_rates); n > 0 {
- cSampleRates := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.sample_rates))[:n:n]
- x.SampleRates = make([]uint32, n)
- for i, v := range cSampleRates {
- x.SampleRates[i] = uint32(v)
- }
- }
- x.SampleFormats = nil
- if n := int(xc.num_sample_formats); n > 0 {
- cSampleFormats := (*[1 << 28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc.sample_formats))[:n:n]
- x.SampleFormats = make([]VsndPcmFormat, n)
- 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)
-
- return nil
-}
-
-func (x *VsndParams) toC(xc *C.libxl_vsnd_params) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vsnd_params_dispose(xc)
- }
- }()
-
- if numSampleRates := len(x.SampleRates); numSampleRates > 0 {
- xc.sample_rates = (*C.uint32_t)(C.malloc(C.size_t(numSampleRates * numSampleRates)))
- xc.num_sample_rates = C.int(numSampleRates)
- cSampleRates := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.sample_rates))[:numSampleRates:numSampleRates]
- for i, v := range x.SampleRates {
- cSampleRates[i] = C.uint32_t(v)
- }
- }
- if numSampleFormats := len(x.SampleFormats); numSampleFormats > 0 {
- xc.sample_formats = (*C.libxl_vsnd_pcm_format)(C.malloc(C.size_t(numSampleFormats * numSampleFormats)))
- xc.num_sample_formats = C.int(numSampleFormats)
- cSampleFormats := (*[1 << 28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc.sample_formats))[:numSampleFormats:numSampleFormats]
- for i, v := range x.SampleFormats {
- cSampleFormats[i] = C.libxl_vsnd_pcm_format(v)
- }
- }
- xc.channels_min = C.uint32_t(x.ChannelsMin)
- xc.channels_max = C.uint32_t(x.ChannelsMax)
- xc.buffer_size = C.uint32_t(x.BufferSize)
-
- return nil
+ x.SampleRates = nil
+if n := int(xc.num_sample_rates); n > 0 {
+cSampleRates := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.sample_rates))[:n:n]
+x.SampleRates = make([]uint32, n)
+for i, v := range cSampleRates {
+x.SampleRates[i] = uint32(v)
+}
+}
+x.SampleFormats = nil
+if n := int(xc.num_sample_formats); n > 0 {
+cSampleFormats := (*[1<<28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc.sample_formats))[:n:n]
+x.SampleFormats = make([]VsndPcmFormat, n)
+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)
+
+ return nil}
+
+func (x *VsndParams) toC(xc *C.libxl_vsnd_params) (err error){defer func(){
+if err != nil{
+C.libxl_vsnd_params_dispose(xc)}
+}()
+
+if numSampleRates := len(x.SampleRates); numSampleRates > 0 {
+xc.sample_rates = (*C.uint32_t)(C.malloc(C.size_t(numSampleRates*numSampleRates)))
+xc.num_sample_rates = C.int(numSampleRates)
+cSampleRates := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.sample_rates))[:numSampleRates:numSampleRates]
+for i,v := range x.SampleRates {
+cSampleRates[i] = C.uint32_t(v)
+}
+}
+if numSampleFormats := len(x.SampleFormats); numSampleFormats > 0 {
+xc.sample_formats = (*C.libxl_vsnd_pcm_format)(C.malloc(C.size_t(numSampleFormats*numSampleFormats)))
+xc.num_sample_formats = C.int(numSampleFormats)
+cSampleFormats := (*[1<<28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc.sample_formats))[:numSampleFormats:numSampleFormats]
+for i,v := range x.SampleFormats {
+cSampleFormats[i] = C.libxl_vsnd_pcm_format(v)
+}
+}
+xc.channels_min = C.uint32_t(x.ChannelsMin)
+xc.channels_max = C.uint32_t(x.ChannelsMax)
+xc.buffer_size = C.uint32_t(x.BufferSize)
+
+ return nil
+ }
// NewVsndStream returns an instance of VsndStream initialized with defaults.
func NewVsndStream() (*VsndStream, error) {
- var (
- x VsndStream
- xc C.libxl_vsnd_stream
- )
+var (
+x VsndStream
+xc C.libxl_vsnd_stream)
- C.libxl_vsnd_stream_init(&xc)
- defer C.libxl_vsnd_stream_dispose(&xc)
+C.libxl_vsnd_stream_init(&xc)
+defer C.libxl_vsnd_stream_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *VsndStream) fromC(xc *C.libxl_vsnd_stream) error {
- x.UniqueId = C.GoString(xc.unique_id)
- x.Type = VsndStreamType(xc._type)
- if err := x.Params.fromC(&xc.params); err != nil {
- return fmt.Errorf("converting field Params: %v", err)
- }
-
- return nil
+ x.UniqueId = C.GoString(xc.unique_id)
+x.Type = VsndStreamType(xc._type)
+if err := x.Params.fromC(&xc.params);err != nil {
+return fmt.Errorf("converting field Params: %v", err)
}
-func (x *VsndStream) toC(xc *C.libxl_vsnd_stream) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vsnd_stream_dispose(xc)
- }
- }()
+ return nil}
- if x.UniqueId != "" {
- xc.unique_id = C.CString(x.UniqueId)
- }
- xc._type = C.libxl_vsnd_stream_type(x.Type)
- if err := x.Params.toC(&xc.params); err != nil {
- return fmt.Errorf("converting field Params: %v", err)
- }
+func (x *VsndStream) toC(xc *C.libxl_vsnd_stream) (err error){defer func(){
+if err != nil{
+C.libxl_vsnd_stream_dispose(xc)}
+}()
- return nil
+if x.UniqueId != "" {
+xc.unique_id = C.CString(x.UniqueId)}
+xc._type = C.libxl_vsnd_stream_type(x.Type)
+if err := x.Params.toC(&xc.params); err != nil {
+return fmt.Errorf("converting field Params: %v", err)
}
+ return nil
+ }
+
// NewVsndPcm returns an instance of VsndPcm initialized with defaults.
func NewVsndPcm() (*VsndPcm, error) {
- var (
- x VsndPcm
- xc C.libxl_vsnd_pcm
- )
+var (
+x VsndPcm
+xc C.libxl_vsnd_pcm)
- C.libxl_vsnd_pcm_init(&xc)
- defer C.libxl_vsnd_pcm_dispose(&xc)
+C.libxl_vsnd_pcm_init(&xc)
+defer C.libxl_vsnd_pcm_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error {
- x.Name = C.GoString(xc.name)
- if err := x.Params.fromC(&xc.params); err != nil {
- return fmt.Errorf("converting field Params: %v", err)
- }
- x.Streams = nil
- if n := int(xc.num_vsnd_streams); n > 0 {
- cStreams := (*[1 << 28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams))[:n:n]
- x.Streams = make([]VsndStream, n)
- for i, v := range cStreams {
- if err := x.Streams[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Streams: %v", err)
- }
- }
- }
-
- return nil
-}
-
-func (x *VsndPcm) toC(xc *C.libxl_vsnd_pcm) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vsnd_pcm_dispose(xc)
- }
- }()
-
- if x.Name != "" {
- xc.name = C.CString(x.Name)
- }
- if err := x.Params.toC(&xc.params); err != nil {
- return fmt.Errorf("converting field Params: %v", err)
- }
- if numVsndStreams := len(x.Streams); numVsndStreams > 0 {
- xc.streams = (*C.libxl_vsnd_stream)(C.malloc(C.ulong(numVsndStreams) * C.sizeof_libxl_vsnd_stream))
- xc.num_vsnd_streams = C.int(numVsndStreams)
- cStreams := (*[1 << 28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams]
- for i, v := range x.Streams {
- if err := v.toC(&cStreams[i]); err != nil {
- return fmt.Errorf("converting field Streams: %v", err)
- }
- }
- }
-
- return nil
+ x.Name = C.GoString(xc.name)
+if err := x.Params.fromC(&xc.params);err != nil {
+return fmt.Errorf("converting field Params: %v", err)
+}
+x.Streams = nil
+if n := int(xc.num_vsnd_streams); n > 0 {
+cStreams := (*[1<<28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams))[:n:n]
+x.Streams = make([]VsndStream, n)
+for i, v := range cStreams {
+if err := x.Streams[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Streams: %v", err) }
+}
}
+ return nil}
+
+func (x *VsndPcm) toC(xc *C.libxl_vsnd_pcm) (err error){defer func(){
+if err != nil{
+C.libxl_vsnd_pcm_dispose(xc)}
+}()
+
+if x.Name != "" {
+xc.name = C.CString(x.Name)}
+if err := x.Params.toC(&xc.params); err != nil {
+return fmt.Errorf("converting field Params: %v", err)
+}
+if numVsndStreams := len(x.Streams); numVsndStreams > 0 {
+xc.streams = (*C.libxl_vsnd_stream)(C.malloc(C.ulong(numVsndStreams)*C.sizeof_libxl_vsnd_stream))
+xc.num_vsnd_streams = C.int(numVsndStreams)
+cStreams := (*[1<<28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams]
+for i,v := range x.Streams {
+if err := v.toC(&cStreams[i]); err != nil {
+return fmt.Errorf("converting field Streams: %v", err)
+}
+}
+}
+
+ return nil
+ }
+
// NewDeviceVsnd returns an instance of DeviceVsnd initialized with defaults.
func NewDeviceVsnd() (*DeviceVsnd, error) {
- var (
- x DeviceVsnd
- xc C.libxl_device_vsnd
- )
+var (
+x DeviceVsnd
+xc C.libxl_device_vsnd)
- C.libxl_device_vsnd_init(&xc)
- defer C.libxl_device_vsnd_dispose(&xc)
+C.libxl_device_vsnd_init(&xc)
+defer C.libxl_device_vsnd_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error {
- x.BackendDomid = Domid(xc.backend_domid)
- x.BackendDomname = C.GoString(xc.backend_domname)
- x.Devid = Devid(xc.devid)
- x.ShortName = C.GoString(xc.short_name)
- x.LongName = C.GoString(xc.long_name)
- if err := x.Params.fromC(&xc.params); err != nil {
- return fmt.Errorf("converting field Params: %v", err)
- }
- x.Pcms = nil
- if n := int(xc.num_vsnd_pcms); n > 0 {
- cPcms := (*[1 << 28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:n:n]
- x.Pcms = make([]VsndPcm, n)
- for i, v := range cPcms {
- if err := x.Pcms[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Pcms: %v", err)
- }
- }
- }
-
- return nil
-}
-
-func (x *DeviceVsnd) toC(xc *C.libxl_device_vsnd) (err error) {
- defer func() {
- if err != nil {
- C.libxl_device_vsnd_dispose(xc)
- }
- }()
-
- xc.backend_domid = C.libxl_domid(x.BackendDomid)
- if x.BackendDomname != "" {
- xc.backend_domname = C.CString(x.BackendDomname)
- }
- xc.devid = C.libxl_devid(x.Devid)
- if x.ShortName != "" {
- xc.short_name = C.CString(x.ShortName)
- }
- if x.LongName != "" {
- xc.long_name = C.CString(x.LongName)
- }
- if err := x.Params.toC(&xc.params); err != nil {
- return fmt.Errorf("converting field Params: %v", err)
- }
- if numVsndPcms := len(x.Pcms); numVsndPcms > 0 {
- xc.pcms = (*C.libxl_vsnd_pcm)(C.malloc(C.ulong(numVsndPcms) * C.sizeof_libxl_vsnd_pcm))
- xc.num_vsnd_pcms = C.int(numVsndPcms)
- cPcms := (*[1 << 28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms]
- for i, v := range x.Pcms {
- if err := v.toC(&cPcms[i]); err != nil {
- return fmt.Errorf("converting field Pcms: %v", err)
- }
- }
- }
-
- return nil
+ x.BackendDomid = Domid(xc.backend_domid)
+x.BackendDomname = C.GoString(xc.backend_domname)
+x.Devid = Devid(xc.devid)
+x.ShortName = C.GoString(xc.short_name)
+x.LongName = C.GoString(xc.long_name)
+if err := x.Params.fromC(&xc.params);err != nil {
+return fmt.Errorf("converting field Params: %v", err)
+}
+x.Pcms = nil
+if n := int(xc.num_vsnd_pcms); n > 0 {
+cPcms := (*[1<<28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:n:n]
+x.Pcms = make([]VsndPcm, n)
+for i, v := range cPcms {
+if err := x.Pcms[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Pcms: %v", err) }
}
+}
+
+ return nil}
+
+func (x *DeviceVsnd) toC(xc *C.libxl_device_vsnd) (err error){defer func(){
+if err != nil{
+C.libxl_device_vsnd_dispose(xc)}
+}()
+
+xc.backend_domid = C.libxl_domid(x.BackendDomid)
+if x.BackendDomname != "" {
+xc.backend_domname = C.CString(x.BackendDomname)}
+xc.devid = C.libxl_devid(x.Devid)
+if x.ShortName != "" {
+xc.short_name = C.CString(x.ShortName)}
+if x.LongName != "" {
+xc.long_name = C.CString(x.LongName)}
+if err := x.Params.toC(&xc.params); err != nil {
+return fmt.Errorf("converting field Params: %v", err)
+}
+if numVsndPcms := len(x.Pcms); numVsndPcms > 0 {
+xc.pcms = (*C.libxl_vsnd_pcm)(C.malloc(C.ulong(numVsndPcms)*C.sizeof_libxl_vsnd_pcm))
+xc.num_vsnd_pcms = C.int(numVsndPcms)
+cPcms := (*[1<<28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms]
+for i,v := range x.Pcms {
+if err := v.toC(&cPcms[i]); err != nil {
+return fmt.Errorf("converting field Pcms: %v", err)
+}
+}
+}
+
+ return nil
+ }
// NewDomainConfig returns an instance of DomainConfig initialized with defaults.
func NewDomainConfig() (*DomainConfig, error) {
- var (
- x DomainConfig
- xc C.libxl_domain_config
- )
+var (
+x DomainConfig
+xc C.libxl_domain_config)
- C.libxl_domain_config_init(&xc)
- defer C.libxl_domain_config_dispose(&xc)
+C.libxl_domain_config_init(&xc)
+defer C.libxl_domain_config_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error {
- if err := x.CInfo.fromC(&xc.c_info); err != nil {
- return fmt.Errorf("converting field CInfo: %v", err)
- }
- if err := x.BInfo.fromC(&xc.b_info); err != nil {
- return fmt.Errorf("converting field BInfo: %v", err)
- }
- x.Disks = nil
- if n := int(xc.num_disks); n > 0 {
- cDisks := (*[1 << 28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:n:n]
- x.Disks = make([]DeviceDisk, n)
- for i, v := range cDisks {
- if err := x.Disks[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Disks: %v", err)
- }
- }
- }
- x.Nics = nil
- if n := int(xc.num_nics); n > 0 {
- cNics := (*[1 << 28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:n:n]
- x.Nics = make([]DeviceNic, n)
- for i, v := range cNics {
- if err := x.Nics[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Nics: %v", err)
- }
- }
- }
- x.Pcidevs = nil
- if n := int(xc.num_pcidevs); n > 0 {
- cPcidevs := (*[1 << 28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))[:n:n]
- x.Pcidevs = make([]DevicePci, n)
- for i, v := range cPcidevs {
- if err := x.Pcidevs[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Pcidevs: %v", err)
- }
- }
- }
- x.Rdms = nil
- if n := int(xc.num_rdms); n > 0 {
- cRdms := (*[1 << 28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:n:n]
- x.Rdms = make([]DeviceRdm, n)
- for i, v := range cRdms {
- if err := x.Rdms[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Rdms: %v", err)
- }
- }
- }
- x.Dtdevs = nil
- if n := int(xc.num_dtdevs); n > 0 {
- cDtdevs := (*[1 << 28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))[:n:n]
- x.Dtdevs = make([]DeviceDtdev, n)
- for i, v := range cDtdevs {
- if err := x.Dtdevs[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Dtdevs: %v", err)
- }
- }
- }
- x.Vfbs = nil
- if n := int(xc.num_vfbs); n > 0 {
- cVfbs := (*[1 << 28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:n:n]
- x.Vfbs = make([]DeviceVfb, n)
- for i, v := range cVfbs {
- if err := x.Vfbs[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Vfbs: %v", err)
- }
- }
- }
- x.Vkbs = nil
- if n := int(xc.num_vkbs); n > 0 {
- cVkbs := (*[1 << 28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:n:n]
- x.Vkbs = make([]DeviceVkb, n)
- for i, v := range cVkbs {
- if err := x.Vkbs[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Vkbs: %v", err)
- }
- }
- }
- x.Vtpms = nil
- if n := int(xc.num_vtpms); n > 0 {
- cVtpms := (*[1 << 28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:n:n]
- x.Vtpms = make([]DeviceVtpm, n)
- for i, v := range cVtpms {
- if err := x.Vtpms[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Vtpms: %v", err)
- }
- }
- }
- x.P9S = nil
- if n := int(xc.num_p9s); n > 0 {
- cP9S := (*[1 << 28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:n:n]
- x.P9S = make([]DeviceP9, n)
- for i, v := range cP9S {
- if err := x.P9S[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field P9S: %v", err)
- }
- }
- }
- x.Pvcallsifs = nil
- if n := int(xc.num_pvcallsifs); n > 0 {
- cPvcallsifs := (*[1 << 28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.pvcallsifs))[:n:n]
- x.Pvcallsifs = make([]DevicePvcallsif, n)
- for i, v := range cPvcallsifs {
- if err := x.Pvcallsifs[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Pvcallsifs: %v", err)
- }
- }
- }
- x.Vdispls = nil
- if n := int(xc.num_vdispls); n > 0 {
- cVdispls := (*[1 << 28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispls))[:n:n]
- x.Vdispls = make([]DeviceVdispl, n)
- for i, v := range cVdispls {
- if err := x.Vdispls[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Vdispls: %v", err)
- }
- }
- }
- x.Vsnds = nil
- if n := int(xc.num_vsnds); n > 0 {
- cVsnds := (*[1 << 28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:n:n]
- x.Vsnds = make([]DeviceVsnd, n)
- for i, v := range cVsnds {
- if err := x.Vsnds[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Vsnds: %v", err)
- }
- }
- }
- x.Channels = nil
- if n := int(xc.num_channels); n > 0 {
- cChannels := (*[1 << 28]C.libxl_device_channel)(unsafe.Pointer(xc.channels))[:n:n]
- x.Channels = make([]DeviceChannel, n)
- for i, v := range cChannels {
- if err := x.Channels[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Channels: %v", err)
- }
- }
- }
- x.Usbctrls = nil
- if n := int(xc.num_usbctrls); n > 0 {
- cUsbctrls := (*[1 << 28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbctrls))[:n:n]
- x.Usbctrls = make([]DeviceUsbctrl, n)
- for i, v := range cUsbctrls {
- if err := x.Usbctrls[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Usbctrls: %v", err)
- }
- }
- }
- x.Usbdevs = nil
- if n := int(xc.num_usbdevs); n > 0 {
- cUsbdevs := (*[1 << 28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdevs))[:n:n]
- x.Usbdevs = make([]DeviceUsbdev, n)
- for i, v := range cUsbdevs {
- if err := x.Usbdevs[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Usbdevs: %v", err)
- }
- }
- }
- x.OnPoweroff = ActionOnShutdown(xc.on_poweroff)
- x.OnReboot = ActionOnShutdown(xc.on_reboot)
- x.OnWatchdog = ActionOnShutdown(xc.on_watchdog)
- x.OnCrash = ActionOnShutdown(xc.on_crash)
- x.OnSoftReset = ActionOnShutdown(xc.on_soft_reset)
-
- return nil
-}
-
-func (x *DomainConfig) toC(xc *C.libxl_domain_config) (err error) {
- defer func() {
- if err != nil {
- C.libxl_domain_config_dispose(xc)
- }
- }()
-
- if err := x.CInfo.toC(&xc.c_info); err != nil {
- return fmt.Errorf("converting field CInfo: %v", err)
- }
- if err := x.BInfo.toC(&xc.b_info); err != nil {
- return fmt.Errorf("converting field BInfo: %v", err)
- }
- if numDisks := len(x.Disks); numDisks > 0 {
- xc.disks = (*C.libxl_device_disk)(C.malloc(C.ulong(numDisks) * C.sizeof_libxl_device_disk))
- xc.num_disks = C.int(numDisks)
- cDisks := (*[1 << 28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:numDisks:numDisks]
- for i, v := range x.Disks {
- if err := v.toC(&cDisks[i]); err != nil {
- return fmt.Errorf("converting field Disks: %v", err)
- }
- }
- }
- if numNics := len(x.Nics); numNics > 0 {
- xc.nics = (*C.libxl_device_nic)(C.malloc(C.ulong(numNics) * C.sizeof_libxl_device_nic))
- xc.num_nics = C.int(numNics)
- cNics := (*[1 << 28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:numNics:numNics]
- for i, v := range x.Nics {
- if err := v.toC(&cNics[i]); err != nil {
- return fmt.Errorf("converting field Nics: %v", err)
- }
- }
- }
- if numPcidevs := len(x.Pcidevs); numPcidevs > 0 {
- xc.pcidevs = (*C.libxl_device_pci)(C.malloc(C.ulong(numPcidevs) * C.sizeof_libxl_device_pci))
- xc.num_pcidevs = C.int(numPcidevs)
- cPcidevs := (*[1 << 28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))[:numPcidevs:numPcidevs]
- for i, v := range x.Pcidevs {
- if err := v.toC(&cPcidevs[i]); err != nil {
- return fmt.Errorf("converting field Pcidevs: %v", err)
- }
- }
- }
- if numRdms := len(x.Rdms); numRdms > 0 {
- xc.rdms = (*C.libxl_device_rdm)(C.malloc(C.ulong(numRdms) * C.sizeof_libxl_device_rdm))
- xc.num_rdms = C.int(numRdms)
- cRdms := (*[1 << 28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:numRdms:numRdms]
- for i, v := range x.Rdms {
- if err := v.toC(&cRdms[i]); err != nil {
- return fmt.Errorf("converting field Rdms: %v", err)
- }
- }
- }
- if numDtdevs := len(x.Dtdevs); numDtdevs > 0 {
- xc.dtdevs = (*C.libxl_device_dtdev)(C.malloc(C.ulong(numDtdevs) * C.sizeof_libxl_device_dtdev))
- xc.num_dtdevs = C.int(numDtdevs)
- cDtdevs := (*[1 << 28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))[:numDtdevs:numDtdevs]
- for i, v := range x.Dtdevs {
- if err := v.toC(&cDtdevs[i]); err != nil {
- return fmt.Errorf("converting field Dtdevs: %v", err)
- }
- }
- }
- if numVfbs := len(x.Vfbs); numVfbs > 0 {
- xc.vfbs = (*C.libxl_device_vfb)(C.malloc(C.ulong(numVfbs) * C.sizeof_libxl_device_vfb))
- xc.num_vfbs = C.int(numVfbs)
- cVfbs := (*[1 << 28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:numVfbs:numVfbs]
- for i, v := range x.Vfbs {
- if err := v.toC(&cVfbs[i]); err != nil {
- return fmt.Errorf("converting field Vfbs: %v", err)
- }
- }
- }
- if numVkbs := len(x.Vkbs); numVkbs > 0 {
- xc.vkbs = (*C.libxl_device_vkb)(C.malloc(C.ulong(numVkbs) * C.sizeof_libxl_device_vkb))
- xc.num_vkbs = C.int(numVkbs)
- cVkbs := (*[1 << 28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:numVkbs:numVkbs]
- for i, v := range x.Vkbs {
- if err := v.toC(&cVkbs[i]); err != nil {
- return fmt.Errorf("converting field Vkbs: %v", err)
- }
- }
- }
- if numVtpms := len(x.Vtpms); numVtpms > 0 {
- xc.vtpms = (*C.libxl_device_vtpm)(C.malloc(C.ulong(numVtpms) * C.sizeof_libxl_device_vtpm))
- xc.num_vtpms = C.int(numVtpms)
- cVtpms := (*[1 << 28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:numVtpms:numVtpms]
- for i, v := range x.Vtpms {
- if err := v.toC(&cVtpms[i]); err != nil {
- return fmt.Errorf("converting field Vtpms: %v", err)
- }
- }
- }
- if numP9S := len(x.P9S); numP9S > 0 {
- xc.p9s = (*C.libxl_device_p9)(C.malloc(C.ulong(numP9S) * C.sizeof_libxl_device_p9))
- xc.num_p9s = C.int(numP9S)
- cP9S := (*[1 << 28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:numP9S:numP9S]
- for i, v := range x.P9S {
- if err := v.toC(&cP9S[i]); err != nil {
- return fmt.Errorf("converting field P9S: %v", err)
- }
- }
- }
- if numPvcallsifs := len(x.Pvcallsifs); numPvcallsifs > 0 {
- xc.pvcallsifs = (*C.libxl_device_pvcallsif)(C.malloc(C.ulong(numPvcallsifs) * C.sizeof_libxl_device_pvcallsif))
- xc.num_pvcallsifs = C.int(numPvcallsifs)
- cPvcallsifs := (*[1 << 28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.pvcallsifs))[:numPvcallsifs:numPvcallsifs]
- for i, v := range x.Pvcallsifs {
- if err := v.toC(&cPvcallsifs[i]); err != nil {
- return fmt.Errorf("converting field Pvcallsifs: %v", err)
- }
- }
- }
- if numVdispls := len(x.Vdispls); numVdispls > 0 {
- xc.vdispls = (*C.libxl_device_vdispl)(C.malloc(C.ulong(numVdispls) * C.sizeof_libxl_device_vdispl))
- xc.num_vdispls = C.int(numVdispls)
- cVdispls := (*[1 << 28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispls))[:numVdispls:numVdispls]
- for i, v := range x.Vdispls {
- if err := v.toC(&cVdispls[i]); err != nil {
- return fmt.Errorf("converting field Vdispls: %v", err)
- }
- }
- }
- if numVsnds := len(x.Vsnds); numVsnds > 0 {
- xc.vsnds = (*C.libxl_device_vsnd)(C.malloc(C.ulong(numVsnds) * C.sizeof_libxl_device_vsnd))
- xc.num_vsnds = C.int(numVsnds)
- cVsnds := (*[1 << 28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:numVsnds:numVsnds]
- for i, v := range x.Vsnds {
- if err := v.toC(&cVsnds[i]); err != nil {
- return fmt.Errorf("converting field Vsnds: %v", err)
- }
- }
- }
- if numChannels := len(x.Channels); numChannels > 0 {
- xc.channels = (*C.libxl_device_channel)(C.malloc(C.ulong(numChannels) * C.sizeof_libxl_device_channel))
- xc.num_channels = C.int(numChannels)
- cChannels := (*[1 << 28]C.libxl_device_channel)(unsafe.Pointer(xc.channels))[:numChannels:numChannels]
- for i, v := range x.Channels {
- if err := v.toC(&cChannels[i]); err != nil {
- return fmt.Errorf("converting field Channels: %v", err)
- }
- }
- }
- if numUsbctrls := len(x.Usbctrls); numUsbctrls > 0 {
- xc.usbctrls = (*C.libxl_device_usbctrl)(C.malloc(C.ulong(numUsbctrls) * C.sizeof_libxl_device_usbctrl))
- xc.num_usbctrls = C.int(numUsbctrls)
- cUsbctrls := (*[1 << 28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbctrls))[:numUsbctrls:numUsbctrls]
- for i, v := range x.Usbctrls {
- if err := v.toC(&cUsbctrls[i]); err != nil {
- return fmt.Errorf("converting field Usbctrls: %v", err)
- }
- }
- }
- if numUsbdevs := len(x.Usbdevs); numUsbdevs > 0 {
- xc.usbdevs = (*C.libxl_device_usbdev)(C.malloc(C.ulong(numUsbdevs) * C.sizeof_libxl_device_usbdev))
- xc.num_usbdevs = C.int(numUsbdevs)
- cUsbdevs := (*[1 << 28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdevs))[:numUsbdevs:numUsbdevs]
- for i, v := range x.Usbdevs {
- if err := v.toC(&cUsbdevs[i]); err != nil {
- return fmt.Errorf("converting field Usbdevs: %v", err)
- }
- }
- }
- xc.on_poweroff = C.libxl_action_on_shutdown(x.OnPoweroff)
- xc.on_reboot = C.libxl_action_on_shutdown(x.OnReboot)
- xc.on_watchdog = C.libxl_action_on_shutdown(x.OnWatchdog)
- xc.on_crash = C.libxl_action_on_shutdown(x.OnCrash)
- xc.on_soft_reset = C.libxl_action_on_shutdown(x.OnSoftReset)
-
- return nil
+ if err := x.CInfo.fromC(&xc.c_info);err != nil {
+return fmt.Errorf("converting field CInfo: %v", err)
+}
+if err := x.BInfo.fromC(&xc.b_info);err != nil {
+return fmt.Errorf("converting field BInfo: %v", err)
+}
+x.Disks = nil
+if n := int(xc.num_disks); n > 0 {
+cDisks := (*[1<<28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:n:n]
+x.Disks = make([]DeviceDisk, n)
+for i, v := range cDisks {
+if err := x.Disks[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Disks: %v", err) }
+}
+}
+x.Nics = nil
+if n := int(xc.num_nics); n > 0 {
+cNics := (*[1<<28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:n:n]
+x.Nics = make([]DeviceNic, n)
+for i, v := range cNics {
+if err := x.Nics[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Nics: %v", err) }
+}
+}
+x.Pcidevs = nil
+if n := int(xc.num_pcidevs); n > 0 {
+cPcidevs := (*[1<<28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))[:n:n]
+x.Pcidevs = make([]DevicePci, n)
+for i, v := range cPcidevs {
+if err := x.Pcidevs[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Pcidevs: %v", err) }
+}
+}
+x.Rdms = nil
+if n := int(xc.num_rdms); n > 0 {
+cRdms := (*[1<<28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:n:n]
+x.Rdms = make([]DeviceRdm, n)
+for i, v := range cRdms {
+if err := x.Rdms[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Rdms: %v", err) }
+}
+}
+x.Dtdevs = nil
+if n := int(xc.num_dtdevs); n > 0 {
+cDtdevs := (*[1<<28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))[:n:n]
+x.Dtdevs = make([]DeviceDtdev, n)
+for i, v := range cDtdevs {
+if err := x.Dtdevs[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Dtdevs: %v", err) }
+}
+}
+x.Vfbs = nil
+if n := int(xc.num_vfbs); n > 0 {
+cVfbs := (*[1<<28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:n:n]
+x.Vfbs = make([]DeviceVfb, n)
+for i, v := range cVfbs {
+if err := x.Vfbs[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Vfbs: %v", err) }
+}
+}
+x.Vkbs = nil
+if n := int(xc.num_vkbs); n > 0 {
+cVkbs := (*[1<<28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:n:n]
+x.Vkbs = make([]DeviceVkb, n)
+for i, v := range cVkbs {
+if err := x.Vkbs[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Vkbs: %v", err) }
+}
+}
+x.Vtpms = nil
+if n := int(xc.num_vtpms); n > 0 {
+cVtpms := (*[1<<28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:n:n]
+x.Vtpms = make([]DeviceVtpm, n)
+for i, v := range cVtpms {
+if err := x.Vtpms[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Vtpms: %v", err) }
+}
+}
+x.P9S = nil
+if n := int(xc.num_p9s); n > 0 {
+cP9S := (*[1<<28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:n:n]
+x.P9S = make([]DeviceP9, n)
+for i, v := range cP9S {
+if err := x.P9S[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field P9S: %v", err) }
+}
+}
+x.Pvcallsifs = nil
+if n := int(xc.num_pvcallsifs); n > 0 {
+cPvcallsifs := (*[1<<28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.pvcallsifs))[:n:n]
+x.Pvcallsifs = make([]DevicePvcallsif, n)
+for i, v := range cPvcallsifs {
+if err := x.Pvcallsifs[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Pvcallsifs: %v", err) }
+}
+}
+x.Vdispls = nil
+if n := int(xc.num_vdispls); n > 0 {
+cVdispls := (*[1<<28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispls))[:n:n]
+x.Vdispls = make([]DeviceVdispl, n)
+for i, v := range cVdispls {
+if err := x.Vdispls[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Vdispls: %v", err) }
+}
+}
+x.Vsnds = nil
+if n := int(xc.num_vsnds); n > 0 {
+cVsnds := (*[1<<28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:n:n]
+x.Vsnds = make([]DeviceVsnd, n)
+for i, v := range cVsnds {
+if err := x.Vsnds[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Vsnds: %v", err) }
+}
+}
+x.Channels = nil
+if n := int(xc.num_channels); n > 0 {
+cChannels := (*[1<<28]C.libxl_device_channel)(unsafe.Pointer(xc.channels))[:n:n]
+x.Channels = make([]DeviceChannel, n)
+for i, v := range cChannels {
+if err := x.Channels[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Channels: %v", err) }
+}
+}
+x.Usbctrls = nil
+if n := int(xc.num_usbctrls); n > 0 {
+cUsbctrls := (*[1<<28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbctrls))[:n:n]
+x.Usbctrls = make([]DeviceUsbctrl, n)
+for i, v := range cUsbctrls {
+if err := x.Usbctrls[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Usbctrls: %v", err) }
+}
+}
+x.Usbdevs = nil
+if n := int(xc.num_usbdevs); n > 0 {
+cUsbdevs := (*[1<<28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdevs))[:n:n]
+x.Usbdevs = make([]DeviceUsbdev, n)
+for i, v := range cUsbdevs {
+if err := x.Usbdevs[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Usbdevs: %v", err) }
+}
+}
+x.OnPoweroff = ActionOnShutdown(xc.on_poweroff)
+x.OnReboot = ActionOnShutdown(xc.on_reboot)
+x.OnWatchdog = ActionOnShutdown(xc.on_watchdog)
+x.OnCrash = ActionOnShutdown(xc.on_crash)
+x.OnSoftReset = ActionOnShutdown(xc.on_soft_reset)
+
+ return nil}
+
+func (x *DomainConfig) toC(xc *C.libxl_domain_config) (err error){defer func(){
+if err != nil{
+C.libxl_domain_config_dispose(xc)}
+}()
+
+if err := x.CInfo.toC(&xc.c_info); err != nil {
+return fmt.Errorf("converting field CInfo: %v", err)
+}
+if err := x.BInfo.toC(&xc.b_info); err != nil {
+return fmt.Errorf("converting field BInfo: %v", err)
+}
+if numDisks := len(x.Disks); numDisks > 0 {
+xc.disks = (*C.libxl_device_disk)(C.malloc(C.ulong(numDisks)*C.sizeof_libxl_device_disk))
+xc.num_disks = C.int(numDisks)
+cDisks := (*[1<<28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:numDisks:numDisks]
+for i,v := range x.Disks {
+if err := v.toC(&cDisks[i]); err != nil {
+return fmt.Errorf("converting field Disks: %v", err)
+}
+}
+}
+if numNics := len(x.Nics); numNics > 0 {
+xc.nics = (*C.libxl_device_nic)(C.malloc(C.ulong(numNics)*C.sizeof_libxl_device_nic))
+xc.num_nics = C.int(numNics)
+cNics := (*[1<<28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:numNics:numNics]
+for i,v := range x.Nics {
+if err := v.toC(&cNics[i]); err != nil {
+return fmt.Errorf("converting field Nics: %v", err)
+}
+}
+}
+if numPcidevs := len(x.Pcidevs); numPcidevs > 0 {
+xc.pcidevs = (*C.libxl_device_pci)(C.malloc(C.ulong(numPcidevs)*C.sizeof_libxl_device_pci))
+xc.num_pcidevs = C.int(numPcidevs)
+cPcidevs := (*[1<<28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))[:numPcidevs:numPcidevs]
+for i,v := range x.Pcidevs {
+if err := v.toC(&cPcidevs[i]); err != nil {
+return fmt.Errorf("converting field Pcidevs: %v", err)
+}
+}
+}
+if numRdms := len(x.Rdms); numRdms > 0 {
+xc.rdms = (*C.libxl_device_rdm)(C.malloc(C.ulong(numRdms)*C.sizeof_libxl_device_rdm))
+xc.num_rdms = C.int(numRdms)
+cRdms := (*[1<<28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:numRdms:numRdms]
+for i,v := range x.Rdms {
+if err := v.toC(&cRdms[i]); err != nil {
+return fmt.Errorf("converting field Rdms: %v", err)
+}
+}
+}
+if numDtdevs := len(x.Dtdevs); numDtdevs > 0 {
+xc.dtdevs = (*C.libxl_device_dtdev)(C.malloc(C.ulong(numDtdevs)*C.sizeof_libxl_device_dtdev))
+xc.num_dtdevs = C.int(numDtdevs)
+cDtdevs := (*[1<<28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))[:numDtdevs:numDtdevs]
+for i,v := range x.Dtdevs {
+if err := v.toC(&cDtdevs[i]); err != nil {
+return fmt.Errorf("converting field Dtdevs: %v", err)
+}
+}
+}
+if numVfbs := len(x.Vfbs); numVfbs > 0 {
+xc.vfbs = (*C.libxl_device_vfb)(C.malloc(C.ulong(numVfbs)*C.sizeof_libxl_device_vfb))
+xc.num_vfbs = C.int(numVfbs)
+cVfbs := (*[1<<28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:numVfbs:numVfbs]
+for i,v := range x.Vfbs {
+if err := v.toC(&cVfbs[i]); err != nil {
+return fmt.Errorf("converting field Vfbs: %v", err)
+}
+}
+}
+if numVkbs := len(x.Vkbs); numVkbs > 0 {
+xc.vkbs = (*C.libxl_device_vkb)(C.malloc(C.ulong(numVkbs)*C.sizeof_libxl_device_vkb))
+xc.num_vkbs = C.int(numVkbs)
+cVkbs := (*[1<<28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:numVkbs:numVkbs]
+for i,v := range x.Vkbs {
+if err := v.toC(&cVkbs[i]); err != nil {
+return fmt.Errorf("converting field Vkbs: %v", err)
+}
+}
+}
+if numVtpms := len(x.Vtpms); numVtpms > 0 {
+xc.vtpms = (*C.libxl_device_vtpm)(C.malloc(C.ulong(numVtpms)*C.sizeof_libxl_device_vtpm))
+xc.num_vtpms = C.int(numVtpms)
+cVtpms := (*[1<<28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:numVtpms:numVtpms]
+for i,v := range x.Vtpms {
+if err := v.toC(&cVtpms[i]); err != nil {
+return fmt.Errorf("converting field Vtpms: %v", err)
+}
+}
+}
+if numP9S := len(x.P9S); numP9S > 0 {
+xc.p9s = (*C.libxl_device_p9)(C.malloc(C.ulong(numP9S)*C.sizeof_libxl_device_p9))
+xc.num_p9s = C.int(numP9S)
+cP9S := (*[1<<28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:numP9S:numP9S]
+for i,v := range x.P9S {
+if err := v.toC(&cP9S[i]); err != nil {
+return fmt.Errorf("converting field P9S: %v", err)
+}
+}
+}
+if numPvcallsifs := len(x.Pvcallsifs); numPvcallsifs > 0 {
+xc.pvcallsifs = (*C.libxl_device_pvcallsif)(C.malloc(C.ulong(numPvcallsifs)*C.sizeof_libxl_device_pvcallsif))
+xc.num_pvcallsifs = C.int(numPvcallsifs)
+cPvcallsifs := (*[1<<28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.pvcallsifs))[:numPvcallsifs:numPvcallsifs]
+for i,v := range x.Pvcallsifs {
+if err := v.toC(&cPvcallsifs[i]); err != nil {
+return fmt.Errorf("converting field Pvcallsifs: %v", err)
+}
+}
+}
+if numVdispls := len(x.Vdispls); numVdispls > 0 {
+xc.vdispls = (*C.libxl_device_vdispl)(C.malloc(C.ulong(numVdispls)*C.sizeof_libxl_device_vdispl))
+xc.num_vdispls = C.int(numVdispls)
+cVdispls := (*[1<<28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispls))[:numVdispls:numVdispls]
+for i,v := range x.Vdispls {
+if err := v.toC(&cVdispls[i]); err != nil {
+return fmt.Errorf("converting field Vdispls: %v", err)
+}
+}
+}
+if numVsnds := len(x.Vsnds); numVsnds > 0 {
+xc.vsnds = (*C.libxl_device_vsnd)(C.malloc(C.ulong(numVsnds)*C.sizeof_libxl_device_vsnd))
+xc.num_vsnds = C.int(numVsnds)
+cVsnds := (*[1<<28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:numVsnds:numVsnds]
+for i,v := range x.Vsnds {
+if err := v.toC(&cVsnds[i]); err != nil {
+return fmt.Errorf("converting field Vsnds: %v", err)
+}
+}
+}
+if numChannels := len(x.Channels); numChannels > 0 {
+xc.channels = (*C.libxl_device_channel)(C.malloc(C.ulong(numChannels)*C.sizeof_libxl_device_channel))
+xc.num_channels = C.int(numChannels)
+cChannels := (*[1<<28]C.libxl_device_channel)(unsafe.Pointer(xc.channels))[:numChannels:numChannels]
+for i,v := range x.Channels {
+if err := v.toC(&cChannels[i]); err != nil {
+return fmt.Errorf("converting field Channels: %v", err)
+}
+}
+}
+if numUsbctrls := len(x.Usbctrls); numUsbctrls > 0 {
+xc.usbctrls = (*C.libxl_device_usbctrl)(C.malloc(C.ulong(numUsbctrls)*C.sizeof_libxl_device_usbctrl))
+xc.num_usbctrls = C.int(numUsbctrls)
+cUsbctrls := (*[1<<28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbctrls))[:numUsbctrls:numUsbctrls]
+for i,v := range x.Usbctrls {
+if err := v.toC(&cUsbctrls[i]); err != nil {
+return fmt.Errorf("converting field Usbctrls: %v", err)
+}
+}
}
+if numUsbdevs := len(x.Usbdevs); numUsbdevs > 0 {
+xc.usbdevs = (*C.libxl_device_usbdev)(C.malloc(C.ulong(numUsbdevs)*C.sizeof_libxl_device_usbdev))
+xc.num_usbdevs = C.int(numUsbdevs)
+cUsbdevs := (*[1<<28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdevs))[:numUsbdevs:numUsbdevs]
+for i,v := range x.Usbdevs {
+if err := v.toC(&cUsbdevs[i]); err != nil {
+return fmt.Errorf("converting field Usbdevs: %v", err)
+}
+}
+}
+xc.on_poweroff = C.libxl_action_on_shutdown(x.OnPoweroff)
+xc.on_reboot = C.libxl_action_on_shutdown(x.OnReboot)
+xc.on_watchdog = C.libxl_action_on_shutdown(x.OnWatchdog)
+xc.on_crash = C.libxl_action_on_shutdown(x.OnCrash)
+xc.on_soft_reset = C.libxl_action_on_shutdown(x.OnSoftReset)
+
+ return nil
+ }
// NewDiskinfo returns an instance of Diskinfo initialized with defaults.
func NewDiskinfo() (*Diskinfo, error) {
- var (
- x Diskinfo
- xc C.libxl_diskinfo
- )
+var (
+x Diskinfo
+xc C.libxl_diskinfo)
- C.libxl_diskinfo_init(&xc)
- defer C.libxl_diskinfo_dispose(&xc)
+C.libxl_diskinfo_init(&xc)
+defer C.libxl_diskinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error {
- x.Backend = C.GoString(xc.backend)
- x.BackendId = uint32(xc.backend_id)
- x.Frontend = C.GoString(xc.frontend)
- x.FrontendId = uint32(xc.frontend_id)
- x.Devid = Devid(xc.devid)
- x.State = int(xc.state)
- x.Evtch = int(xc.evtch)
- x.Rref = int(xc.rref)
-
- return nil
-}
-
-func (x *Diskinfo) toC(xc *C.libxl_diskinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_diskinfo_dispose(xc)
- }
- }()
-
- if x.Backend != "" {
- xc.backend = C.CString(x.Backend)
- }
- xc.backend_id = C.uint32_t(x.BackendId)
- if x.Frontend != "" {
- xc.frontend = C.CString(x.Frontend)
- }
- xc.frontend_id = C.uint32_t(x.FrontendId)
- xc.devid = C.libxl_devid(x.Devid)
- xc.state = C.int(x.State)
- xc.evtch = C.int(x.Evtch)
- xc.rref = C.int(x.Rref)
-
- return nil
-}
+ x.Backend = C.GoString(xc.backend)
+x.BackendId = uint32(xc.backend_id)
+x.Frontend = C.GoString(xc.frontend)
+x.FrontendId = uint32(xc.frontend_id)
+x.Devid = Devid(xc.devid)
+x.State = int(xc.state)
+x.Evtch = int(xc.evtch)
+x.Rref = int(xc.rref)
+
+ return nil}
+
+func (x *Diskinfo) toC(xc *C.libxl_diskinfo) (err error){defer func(){
+if err != nil{
+C.libxl_diskinfo_dispose(xc)}
+}()
+
+if x.Backend != "" {
+xc.backend = C.CString(x.Backend)}
+xc.backend_id = C.uint32_t(x.BackendId)
+if x.Frontend != "" {
+xc.frontend = C.CString(x.Frontend)}
+xc.frontend_id = C.uint32_t(x.FrontendId)
+xc.devid = C.libxl_devid(x.Devid)
+xc.state = C.int(x.State)
+xc.evtch = C.int(x.Evtch)
+xc.rref = C.int(x.Rref)
+
+ return nil
+ }
// NewNicinfo returns an instance of Nicinfo initialized with defaults.
func NewNicinfo() (*Nicinfo, error) {
- var (
- x Nicinfo
- xc C.libxl_nicinfo
- )
+var (
+x Nicinfo
+xc C.libxl_nicinfo)
- C.libxl_nicinfo_init(&xc)
- defer C.libxl_nicinfo_dispose(&xc)
+C.libxl_nicinfo_init(&xc)
+defer C.libxl_nicinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error {
- x.Backend = C.GoString(xc.backend)
- x.BackendId = uint32(xc.backend_id)
- x.Frontend = C.GoString(xc.frontend)
- x.FrontendId = uint32(xc.frontend_id)
- x.Devid = Devid(xc.devid)
- x.State = int(xc.state)
- x.Evtch = int(xc.evtch)
- x.RrefTx = int(xc.rref_tx)
- x.RrefRx = int(xc.rref_rx)
-
- return nil
-}
-
-func (x *Nicinfo) toC(xc *C.libxl_nicinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_nicinfo_dispose(xc)
- }
- }()
-
- if x.Backend != "" {
- xc.backend = C.CString(x.Backend)
- }
- xc.backend_id = C.uint32_t(x.BackendId)
- if x.Frontend != "" {
- xc.frontend = C.CString(x.Frontend)
- }
- xc.frontend_id = C.uint32_t(x.FrontendId)
- xc.devid = C.libxl_devid(x.Devid)
- xc.state = C.int(x.State)
- xc.evtch = C.int(x.Evtch)
- xc.rref_tx = C.int(x.RrefTx)
- xc.rref_rx = C.int(x.RrefRx)
-
- return nil
-}
+ x.Backend = C.GoString(xc.backend)
+x.BackendId = uint32(xc.backend_id)
+x.Frontend = C.GoString(xc.frontend)
+x.FrontendId = uint32(xc.frontend_id)
+x.Devid = Devid(xc.devid)
+x.State = int(xc.state)
+x.Evtch = int(xc.evtch)
+x.RrefTx = int(xc.rref_tx)
+x.RrefRx = int(xc.rref_rx)
+
+ return nil}
+
+func (x *Nicinfo) toC(xc *C.libxl_nicinfo) (err error){defer func(){
+if err != nil{
+C.libxl_nicinfo_dispose(xc)}
+}()
+
+if x.Backend != "" {
+xc.backend = C.CString(x.Backend)}
+xc.backend_id = C.uint32_t(x.BackendId)
+if x.Frontend != "" {
+xc.frontend = C.CString(x.Frontend)}
+xc.frontend_id = C.uint32_t(x.FrontendId)
+xc.devid = C.libxl_devid(x.Devid)
+xc.state = C.int(x.State)
+xc.evtch = C.int(x.Evtch)
+xc.rref_tx = C.int(x.RrefTx)
+xc.rref_rx = C.int(x.RrefRx)
+
+ return nil
+ }
// NewVtpminfo returns an instance of Vtpminfo initialized with defaults.
func NewVtpminfo() (*Vtpminfo, error) {
- var (
- x Vtpminfo
- xc C.libxl_vtpminfo
- )
+var (
+x Vtpminfo
+xc C.libxl_vtpminfo)
- C.libxl_vtpminfo_init(&xc)
- defer C.libxl_vtpminfo_dispose(&xc)
+C.libxl_vtpminfo_init(&xc)
+defer C.libxl_vtpminfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error {
- x.Backend = C.GoString(xc.backend)
- x.BackendId = uint32(xc.backend_id)
- x.Frontend = C.GoString(xc.frontend)
- x.FrontendId = uint32(xc.frontend_id)
- x.Devid = Devid(xc.devid)
- x.State = int(xc.state)
- x.Evtch = int(xc.evtch)
- x.Rref = int(xc.rref)
- if err := x.Uuid.fromC(&xc.uuid); err != nil {
- return fmt.Errorf("converting field Uuid: %v", err)
- }
-
- return nil
-}
-
-func (x *Vtpminfo) toC(xc *C.libxl_vtpminfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vtpminfo_dispose(xc)
- }
- }()
-
- if x.Backend != "" {
- xc.backend = C.CString(x.Backend)
- }
- xc.backend_id = C.uint32_t(x.BackendId)
- if x.Frontend != "" {
- xc.frontend = C.CString(x.Frontend)
- }
- xc.frontend_id = C.uint32_t(x.FrontendId)
- xc.devid = C.libxl_devid(x.Devid)
- xc.state = C.int(x.State)
- xc.evtch = C.int(x.Evtch)
- xc.rref = C.int(x.Rref)
- if err := x.Uuid.toC(&xc.uuid); err != nil {
- return fmt.Errorf("converting field Uuid: %v", err)
- }
-
- return nil
-}
+ x.Backend = C.GoString(xc.backend)
+x.BackendId = uint32(xc.backend_id)
+x.Frontend = C.GoString(xc.frontend)
+x.FrontendId = uint32(xc.frontend_id)
+x.Devid = Devid(xc.devid)
+x.State = int(xc.state)
+x.Evtch = int(xc.evtch)
+x.Rref = int(xc.rref)
+if err := x.Uuid.fromC(&xc.uuid);err != nil {
+return fmt.Errorf("converting field Uuid: %v", err)
+}
+
+ return nil}
+
+func (x *Vtpminfo) toC(xc *C.libxl_vtpminfo) (err error){defer func(){
+if err != nil{
+C.libxl_vtpminfo_dispose(xc)}
+}()
+
+if x.Backend != "" {
+xc.backend = C.CString(x.Backend)}
+xc.backend_id = C.uint32_t(x.BackendId)
+if x.Frontend != "" {
+xc.frontend = C.CString(x.Frontend)}
+xc.frontend_id = C.uint32_t(x.FrontendId)
+xc.devid = C.libxl_devid(x.Devid)
+xc.state = C.int(x.State)
+xc.evtch = C.int(x.Evtch)
+xc.rref = C.int(x.Rref)
+if err := x.Uuid.toC(&xc.uuid); err != nil {
+return fmt.Errorf("converting field Uuid: %v", err)
+}
+
+ return nil
+ }
// NewUsbctrlinfo returns an instance of Usbctrlinfo initialized with defaults.
func NewUsbctrlinfo() (*Usbctrlinfo, error) {
- var (
- x Usbctrlinfo
- xc C.libxl_usbctrlinfo
- )
+var (
+x Usbctrlinfo
+xc C.libxl_usbctrlinfo)
- C.libxl_usbctrlinfo_init(&xc)
- defer C.libxl_usbctrlinfo_dispose(&xc)
+C.libxl_usbctrlinfo_init(&xc)
+defer C.libxl_usbctrlinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo) error {
- x.Type = UsbctrlType(xc._type)
- x.Devid = Devid(xc.devid)
- x.Version = int(xc.version)
- x.Ports = int(xc.ports)
- x.Backend = C.GoString(xc.backend)
- x.BackendId = uint32(xc.backend_id)
- x.Frontend = C.GoString(xc.frontend)
- x.FrontendId = uint32(xc.frontend_id)
- x.State = int(xc.state)
- x.Evtch = int(xc.evtch)
- x.RefUrb = int(xc.ref_urb)
- x.RefConn = int(xc.ref_conn)
-
- return nil
-}
-
-func (x *Usbctrlinfo) toC(xc *C.libxl_usbctrlinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_usbctrlinfo_dispose(xc)
- }
- }()
-
- xc._type = C.libxl_usbctrl_type(x.Type)
- xc.devid = C.libxl_devid(x.Devid)
- xc.version = C.int(x.Version)
- xc.ports = C.int(x.Ports)
- if x.Backend != "" {
- xc.backend = C.CString(x.Backend)
- }
- xc.backend_id = C.uint32_t(x.BackendId)
- if x.Frontend != "" {
- xc.frontend = C.CString(x.Frontend)
- }
- xc.frontend_id = C.uint32_t(x.FrontendId)
- xc.state = C.int(x.State)
- xc.evtch = C.int(x.Evtch)
- xc.ref_urb = C.int(x.RefUrb)
- xc.ref_conn = C.int(x.RefConn)
-
- return nil
-}
+ x.Type = UsbctrlType(xc._type)
+x.Devid = Devid(xc.devid)
+x.Version = int(xc.version)
+x.Ports = int(xc.ports)
+x.Backend = C.GoString(xc.backend)
+x.BackendId = uint32(xc.backend_id)
+x.Frontend = C.GoString(xc.frontend)
+x.FrontendId = uint32(xc.frontend_id)
+x.State = int(xc.state)
+x.Evtch = int(xc.evtch)
+x.RefUrb = int(xc.ref_urb)
+x.RefConn = int(xc.ref_conn)
+
+ return nil}
+
+func (x *Usbctrlinfo) toC(xc *C.libxl_usbctrlinfo) (err error){defer func(){
+if err != nil{
+C.libxl_usbctrlinfo_dispose(xc)}
+}()
+
+xc._type = C.libxl_usbctrl_type(x.Type)
+xc.devid = C.libxl_devid(x.Devid)
+xc.version = C.int(x.Version)
+xc.ports = C.int(x.Ports)
+if x.Backend != "" {
+xc.backend = C.CString(x.Backend)}
+xc.backend_id = C.uint32_t(x.BackendId)
+if x.Frontend != "" {
+xc.frontend = C.CString(x.Frontend)}
+xc.frontend_id = C.uint32_t(x.FrontendId)
+xc.state = C.int(x.State)
+xc.evtch = C.int(x.Evtch)
+xc.ref_urb = C.int(x.RefUrb)
+xc.ref_conn = C.int(x.RefConn)
+
+ return nil
+ }
// NewVcpuinfo returns an instance of Vcpuinfo initialized with defaults.
func NewVcpuinfo() (*Vcpuinfo, error) {
- var (
- x Vcpuinfo
- xc C.libxl_vcpuinfo
- )
+var (
+x Vcpuinfo
+xc C.libxl_vcpuinfo)
- C.libxl_vcpuinfo_init(&xc)
- defer C.libxl_vcpuinfo_dispose(&xc)
+C.libxl_vcpuinfo_init(&xc)
+defer C.libxl_vcpuinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error {
- x.Vcpuid = uint32(xc.vcpuid)
- x.Cpu = uint32(xc.cpu)
- x.Online = bool(xc.online)
- x.Blocked = bool(xc.blocked)
- x.Running = bool(xc.running)
- x.VcpuTime = uint64(xc.vcpu_time)
- if err := x.Cpumap.fromC(&xc.cpumap); err != nil {
- return fmt.Errorf("converting field Cpumap: %v", err)
- }
- if err := x.CpumapSoft.fromC(&xc.cpumap_soft); err != nil {
- return fmt.Errorf("converting field CpumapSoft: %v", err)
- }
-
- return nil
-}
-
-func (x *Vcpuinfo) toC(xc *C.libxl_vcpuinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vcpuinfo_dispose(xc)
- }
- }()
-
- xc.vcpuid = C.uint32_t(x.Vcpuid)
- xc.cpu = C.uint32_t(x.Cpu)
- xc.online = C.bool(x.Online)
- xc.blocked = C.bool(x.Blocked)
- xc.running = C.bool(x.Running)
- xc.vcpu_time = C.uint64_t(x.VcpuTime)
- if err := x.Cpumap.toC(&xc.cpumap); err != nil {
- return fmt.Errorf("converting field Cpumap: %v", err)
- }
- if err := x.CpumapSoft.toC(&xc.cpumap_soft); err != nil {
- return fmt.Errorf("converting field CpumapSoft: %v", err)
- }
-
- return nil
+ x.Vcpuid = uint32(xc.vcpuid)
+x.Cpu = uint32(xc.cpu)
+x.Online = bool(xc.online)
+x.Blocked = bool(xc.blocked)
+x.Running = bool(xc.running)
+x.VcpuTime = uint64(xc.vcpu_time)
+if err := x.Cpumap.fromC(&xc.cpumap);err != nil {
+return fmt.Errorf("converting field Cpumap: %v", err)
+}
+if err := x.CpumapSoft.fromC(&xc.cpumap_soft);err != nil {
+return fmt.Errorf("converting field CpumapSoft: %v", err)
+}
+
+ return nil}
+
+func (x *Vcpuinfo) toC(xc *C.libxl_vcpuinfo) (err error){defer func(){
+if err != nil{
+C.libxl_vcpuinfo_dispose(xc)}
+}()
+
+xc.vcpuid = C.uint32_t(x.Vcpuid)
+xc.cpu = C.uint32_t(x.Cpu)
+xc.online = C.bool(x.Online)
+xc.blocked = C.bool(x.Blocked)
+xc.running = C.bool(x.Running)
+xc.vcpu_time = C.uint64_t(x.VcpuTime)
+if err := x.Cpumap.toC(&xc.cpumap); err != nil {
+return fmt.Errorf("converting field Cpumap: %v", err)
+}
+if err := x.CpumapSoft.toC(&xc.cpumap_soft); err != nil {
+return fmt.Errorf("converting field CpumapSoft: %v", err)
}
+ return nil
+ }
+
// NewPhysinfo returns an instance of Physinfo initialized with defaults.
func NewPhysinfo() (*Physinfo, error) {
- var (
- x Physinfo
- xc C.libxl_physinfo
- )
+var (
+x Physinfo
+xc C.libxl_physinfo)
- C.libxl_physinfo_init(&xc)
- defer C.libxl_physinfo_dispose(&xc)
+C.libxl_physinfo_init(&xc)
+defer C.libxl_physinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Physinfo) fromC(xc *C.libxl_physinfo) error {
- x.ThreadsPerCore = uint32(xc.threads_per_core)
- x.CoresPerSocket = uint32(xc.cores_per_socket)
- x.MaxCpuId = uint32(xc.max_cpu_id)
- x.NrCpus = uint32(xc.nr_cpus)
- x.CpuKhz = uint32(xc.cpu_khz)
- x.TotalPages = uint64(xc.total_pages)
- x.FreePages = uint64(xc.free_pages)
- x.ScrubPages = uint64(xc.scrub_pages)
- x.OutstandingPages = uint64(xc.outstanding_pages)
- x.SharingFreedPages = uint64(xc.sharing_freed_pages)
- x.SharingUsedFrames = uint64(xc.sharing_used_frames)
- x.MaxPossibleMfn = uint64(xc.max_possible_mfn)
- x.NrNodes = uint32(xc.nr_nodes)
- if err := x.HwCap.fromC(&xc.hw_cap); err != nil {
- return fmt.Errorf("converting field HwCap: %v", err)
- }
- x.CapHvm = bool(xc.cap_hvm)
- x.CapPv = bool(xc.cap_pv)
- x.CapHvmDirectio = bool(xc.cap_hvm_directio)
- x.CapHap = bool(xc.cap_hap)
- x.CapShadow = bool(xc.cap_shadow)
- x.CapIommuHapPtShare = bool(xc.cap_iommu_hap_pt_share)
-
- return nil
-}
-
-func (x *Physinfo) toC(xc *C.libxl_physinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_physinfo_dispose(xc)
- }
- }()
-
- xc.threads_per_core = C.uint32_t(x.ThreadsPerCore)
- xc.cores_per_socket = C.uint32_t(x.CoresPerSocket)
- xc.max_cpu_id = C.uint32_t(x.MaxCpuId)
- xc.nr_cpus = C.uint32_t(x.NrCpus)
- xc.cpu_khz = C.uint32_t(x.CpuKhz)
- xc.total_pages = C.uint64_t(x.TotalPages)
- xc.free_pages = C.uint64_t(x.FreePages)
- xc.scrub_pages = C.uint64_t(x.ScrubPages)
- xc.outstanding_pages = C.uint64_t(x.OutstandingPages)
- xc.sharing_freed_pages = C.uint64_t(x.SharingFreedPages)
- xc.sharing_used_frames = C.uint64_t(x.SharingUsedFrames)
- xc.max_possible_mfn = C.uint64_t(x.MaxPossibleMfn)
- xc.nr_nodes = C.uint32_t(x.NrNodes)
- if err := x.HwCap.toC(&xc.hw_cap); err != nil {
- return fmt.Errorf("converting field HwCap: %v", err)
- }
- xc.cap_hvm = C.bool(x.CapHvm)
- xc.cap_pv = C.bool(x.CapPv)
- xc.cap_hvm_directio = C.bool(x.CapHvmDirectio)
- xc.cap_hap = C.bool(x.CapHap)
- xc.cap_shadow = C.bool(x.CapShadow)
- xc.cap_iommu_hap_pt_share = C.bool(x.CapIommuHapPtShare)
-
- return nil
-}
+ x.ThreadsPerCore = uint32(xc.threads_per_core)
+x.CoresPerSocket = uint32(xc.cores_per_socket)
+x.MaxCpuId = uint32(xc.max_cpu_id)
+x.NrCpus = uint32(xc.nr_cpus)
+x.CpuKhz = uint32(xc.cpu_khz)
+x.TotalPages = uint64(xc.total_pages)
+x.FreePages = uint64(xc.free_pages)
+x.ScrubPages = uint64(xc.scrub_pages)
+x.OutstandingPages = uint64(xc.outstanding_pages)
+x.SharingFreedPages = uint64(xc.sharing_freed_pages)
+x.SharingUsedFrames = uint64(xc.sharing_used_frames)
+x.MaxPossibleMfn = uint64(xc.max_possible_mfn)
+x.NrNodes = uint32(xc.nr_nodes)
+if err := x.HwCap.fromC(&xc.hw_cap);err != nil {
+return fmt.Errorf("converting field HwCap: %v", err)
+}
+x.CapHvm = bool(xc.cap_hvm)
+x.CapPv = bool(xc.cap_pv)
+x.CapHvmDirectio = bool(xc.cap_hvm_directio)
+x.CapHap = bool(xc.cap_hap)
+x.CapShadow = bool(xc.cap_shadow)
+x.CapIommuHapPtShare = bool(xc.cap_iommu_hap_pt_share)
+
+ return nil}
+
+func (x *Physinfo) toC(xc *C.libxl_physinfo) (err error){defer func(){
+if err != nil{
+C.libxl_physinfo_dispose(xc)}
+}()
+
+xc.threads_per_core = C.uint32_t(x.ThreadsPerCore)
+xc.cores_per_socket = C.uint32_t(x.CoresPerSocket)
+xc.max_cpu_id = C.uint32_t(x.MaxCpuId)
+xc.nr_cpus = C.uint32_t(x.NrCpus)
+xc.cpu_khz = C.uint32_t(x.CpuKhz)
+xc.total_pages = C.uint64_t(x.TotalPages)
+xc.free_pages = C.uint64_t(x.FreePages)
+xc.scrub_pages = C.uint64_t(x.ScrubPages)
+xc.outstanding_pages = C.uint64_t(x.OutstandingPages)
+xc.sharing_freed_pages = C.uint64_t(x.SharingFreedPages)
+xc.sharing_used_frames = C.uint64_t(x.SharingUsedFrames)
+xc.max_possible_mfn = C.uint64_t(x.MaxPossibleMfn)
+xc.nr_nodes = C.uint32_t(x.NrNodes)
+if err := x.HwCap.toC(&xc.hw_cap); err != nil {
+return fmt.Errorf("converting field HwCap: %v", err)
+}
+xc.cap_hvm = C.bool(x.CapHvm)
+xc.cap_pv = C.bool(x.CapPv)
+xc.cap_hvm_directio = C.bool(x.CapHvmDirectio)
+xc.cap_hap = C.bool(x.CapHap)
+xc.cap_shadow = C.bool(x.CapShadow)
+xc.cap_iommu_hap_pt_share = C.bool(x.CapIommuHapPtShare)
+
+ return nil
+ }
// NewConnectorinfo returns an instance of Connectorinfo initialized with defaults.
func NewConnectorinfo() (*Connectorinfo, error) {
- var (
- x Connectorinfo
- xc C.libxl_connectorinfo
- )
+var (
+x Connectorinfo
+xc C.libxl_connectorinfo)
- C.libxl_connectorinfo_init(&xc)
- defer C.libxl_connectorinfo_dispose(&xc)
+C.libxl_connectorinfo_init(&xc)
+defer C.libxl_connectorinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Connectorinfo) fromC(xc *C.libxl_connectorinfo) error {
- x.UniqueId = C.GoString(xc.unique_id)
- x.Width = uint32(xc.width)
- x.Height = uint32(xc.height)
- x.ReqEvtch = int(xc.req_evtch)
- x.ReqRref = int(xc.req_rref)
- x.EvtEvtch = int(xc.evt_evtch)
- x.EvtRref = int(xc.evt_rref)
-
- return nil
-}
-
-func (x *Connectorinfo) toC(xc *C.libxl_connectorinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_connectorinfo_dispose(xc)
- }
- }()
-
- if x.UniqueId != "" {
- xc.unique_id = C.CString(x.UniqueId)
- }
- xc.width = C.uint32_t(x.Width)
- xc.height = C.uint32_t(x.Height)
- xc.req_evtch = C.int(x.ReqEvtch)
- xc.req_rref = C.int(x.ReqRref)
- xc.evt_evtch = C.int(x.EvtEvtch)
- xc.evt_rref = C.int(x.EvtRref)
-
- return nil
-}
+ x.UniqueId = C.GoString(xc.unique_id)
+x.Width = uint32(xc.width)
+x.Height = uint32(xc.height)
+x.ReqEvtch = int(xc.req_evtch)
+x.ReqRref = int(xc.req_rref)
+x.EvtEvtch = int(xc.evt_evtch)
+x.EvtRref = int(xc.evt_rref)
+
+ return nil}
+
+func (x *Connectorinfo) toC(xc *C.libxl_connectorinfo) (err error){defer func(){
+if err != nil{
+C.libxl_connectorinfo_dispose(xc)}
+}()
+
+if x.UniqueId != "" {
+xc.unique_id = C.CString(x.UniqueId)}
+xc.width = C.uint32_t(x.Width)
+xc.height = C.uint32_t(x.Height)
+xc.req_evtch = C.int(x.ReqEvtch)
+xc.req_rref = C.int(x.ReqRref)
+xc.evt_evtch = C.int(x.EvtEvtch)
+xc.evt_rref = C.int(x.EvtRref)
+
+ return nil
+ }
// NewVdisplinfo returns an instance of Vdisplinfo initialized with defaults.
func NewVdisplinfo() (*Vdisplinfo, error) {
- var (
- x Vdisplinfo
- xc C.libxl_vdisplinfo
- )
+var (
+x Vdisplinfo
+xc C.libxl_vdisplinfo)
- C.libxl_vdisplinfo_init(&xc)
- defer C.libxl_vdisplinfo_dispose(&xc)
+C.libxl_vdisplinfo_init(&xc)
+defer C.libxl_vdisplinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error {
- x.Backend = C.GoString(xc.backend)
- x.BackendId = uint32(xc.backend_id)
- x.Frontend = C.GoString(xc.frontend)
- x.FrontendId = uint32(xc.frontend_id)
- x.Devid = Devid(xc.devid)
- x.State = int(xc.state)
- x.BeAlloc = bool(xc.be_alloc)
- x.Connectors = nil
- if n := int(xc.num_connectors); n > 0 {
- cConnectors := (*[1 << 28]C.libxl_connectorinfo)(unsafe.Pointer(xc.connectors))[:n:n]
- x.Connectors = make([]Connectorinfo, n)
- for i, v := range cConnectors {
- if err := x.Connectors[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Connectors: %v", err)
- }
- }
- }
-
- return nil
-}
-
-func (x *Vdisplinfo) toC(xc *C.libxl_vdisplinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vdisplinfo_dispose(xc)
- }
- }()
-
- if x.Backend != "" {
- xc.backend = C.CString(x.Backend)
- }
- xc.backend_id = C.uint32_t(x.BackendId)
- if x.Frontend != "" {
- xc.frontend = C.CString(x.Frontend)
- }
- xc.frontend_id = C.uint32_t(x.FrontendId)
- xc.devid = C.libxl_devid(x.Devid)
- xc.state = C.int(x.State)
- xc.be_alloc = C.bool(x.BeAlloc)
- if numConnectors := len(x.Connectors); numConnectors > 0 {
- xc.connectors = (*C.libxl_connectorinfo)(C.malloc(C.ulong(numConnectors) * C.sizeof_libxl_connectorinfo))
- xc.num_connectors = C.int(numConnectors)
- cConnectors := (*[1 << 28]C.libxl_connectorinfo)(unsafe.Pointer(xc.connectors))[:numConnectors:numConnectors]
- for i, v := range x.Connectors {
- if err := v.toC(&cConnectors[i]); err != nil {
- return fmt.Errorf("converting field Connectors: %v", err)
- }
- }
- }
-
- return nil
-}
+ x.Backend = C.GoString(xc.backend)
+x.BackendId = uint32(xc.backend_id)
+x.Frontend = C.GoString(xc.frontend)
+x.FrontendId = uint32(xc.frontend_id)
+x.Devid = Devid(xc.devid)
+x.State = int(xc.state)
+x.BeAlloc = bool(xc.be_alloc)
+x.Connectors = nil
+if n := int(xc.num_connectors); n > 0 {
+cConnectors := (*[1<<28]C.libxl_connectorinfo)(unsafe.Pointer(xc.connectors))[:n:n]
+x.Connectors = make([]Connectorinfo, n)
+for i, v := range cConnectors {
+if err := x.Connectors[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Connectors: %v", err) }
+}
+}
+
+ return nil}
+
+func (x *Vdisplinfo) toC(xc *C.libxl_vdisplinfo) (err error){defer func(){
+if err != nil{
+C.libxl_vdisplinfo_dispose(xc)}
+}()
+
+if x.Backend != "" {
+xc.backend = C.CString(x.Backend)}
+xc.backend_id = C.uint32_t(x.BackendId)
+if x.Frontend != "" {
+xc.frontend = C.CString(x.Frontend)}
+xc.frontend_id = C.uint32_t(x.FrontendId)
+xc.devid = C.libxl_devid(x.Devid)
+xc.state = C.int(x.State)
+xc.be_alloc = C.bool(x.BeAlloc)
+if numConnectors := len(x.Connectors); numConnectors > 0 {
+xc.connectors = (*C.libxl_connectorinfo)(C.malloc(C.ulong(numConnectors)*C.sizeof_libxl_connectorinfo))
+xc.num_connectors = C.int(numConnectors)
+cConnectors := (*[1<<28]C.libxl_connectorinfo)(unsafe.Pointer(xc.connectors))[:numConnectors:numConnectors]
+for i,v := range x.Connectors {
+if err := v.toC(&cConnectors[i]); err != nil {
+return fmt.Errorf("converting field Connectors: %v", err)
+}
+}
+}
+
+ return nil
+ }
// NewStreaminfo returns an instance of Streaminfo initialized with defaults.
func NewStreaminfo() (*Streaminfo, error) {
- var (
- x Streaminfo
- xc C.libxl_streaminfo
- )
+var (
+x Streaminfo
+xc C.libxl_streaminfo)
- C.libxl_streaminfo_init(&xc)
- defer C.libxl_streaminfo_dispose(&xc)
+C.libxl_streaminfo_init(&xc)
+defer C.libxl_streaminfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error {
- x.ReqEvtch = int(xc.req_evtch)
- x.ReqRref = int(xc.req_rref)
+ x.ReqEvtch = int(xc.req_evtch)
+x.ReqRref = int(xc.req_rref)
- return nil
-}
+ return nil}
-func (x *Streaminfo) toC(xc *C.libxl_streaminfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_streaminfo_dispose(xc)
- }
- }()
+func (x *Streaminfo) toC(xc *C.libxl_streaminfo) (err error){defer func(){
+if err != nil{
+C.libxl_streaminfo_dispose(xc)}
+}()
- xc.req_evtch = C.int(x.ReqEvtch)
- xc.req_rref = C.int(x.ReqRref)
+xc.req_evtch = C.int(x.ReqEvtch)
+xc.req_rref = C.int(x.ReqRref)
- return nil
-}
+ return nil
+ }
// NewPcminfo returns an instance of Pcminfo initialized with defaults.
func NewPcminfo() (*Pcminfo, error) {
- var (
- x Pcminfo
- xc C.libxl_pcminfo
- )
+var (
+x Pcminfo
+xc C.libxl_pcminfo)
- C.libxl_pcminfo_init(&xc)
- defer C.libxl_pcminfo_dispose(&xc)
+C.libxl_pcminfo_init(&xc)
+defer C.libxl_pcminfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error {
- x.Streams = nil
- if n := int(xc.num_vsnd_streams); n > 0 {
- cStreams := (*[1 << 28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))[:n:n]
- x.Streams = make([]Streaminfo, n)
- for i, v := range cStreams {
- if err := x.Streams[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Streams: %v", err)
- }
- }
- }
-
- return nil
-}
-
-func (x *Pcminfo) toC(xc *C.libxl_pcminfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_pcminfo_dispose(xc)
- }
- }()
-
- if numVsndStreams := len(x.Streams); numVsndStreams > 0 {
- xc.streams = (*C.libxl_streaminfo)(C.malloc(C.ulong(numVsndStreams) * C.sizeof_libxl_streaminfo))
- xc.num_vsnd_streams = C.int(numVsndStreams)
- cStreams := (*[1 << 28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams]
- for i, v := range x.Streams {
- if err := v.toC(&cStreams[i]); err != nil {
- return fmt.Errorf("converting field Streams: %v", err)
- }
- }
- }
-
- return nil
+ x.Streams = nil
+if n := int(xc.num_vsnd_streams); n > 0 {
+cStreams := (*[1<<28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))[:n:n]
+x.Streams = make([]Streaminfo, n)
+for i, v := range cStreams {
+if err := x.Streams[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Streams: %v", err) }
}
+}
+
+ return nil}
+
+func (x *Pcminfo) toC(xc *C.libxl_pcminfo) (err error){defer func(){
+if err != nil{
+C.libxl_pcminfo_dispose(xc)}
+}()
+
+if numVsndStreams := len(x.Streams); numVsndStreams > 0 {
+xc.streams = (*C.libxl_streaminfo)(C.malloc(C.ulong(numVsndStreams)*C.sizeof_libxl_streaminfo))
+xc.num_vsnd_streams = C.int(numVsndStreams)
+cStreams := (*[1<<28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams]
+for i,v := range x.Streams {
+if err := v.toC(&cStreams[i]); err != nil {
+return fmt.Errorf("converting field Streams: %v", err)
+}
+}
+}
+
+ return nil
+ }
// NewVsndinfo returns an instance of Vsndinfo initialized with defaults.
func NewVsndinfo() (*Vsndinfo, error) {
- var (
- x Vsndinfo
- xc C.libxl_vsndinfo
- )
+var (
+x Vsndinfo
+xc C.libxl_vsndinfo)
- C.libxl_vsndinfo_init(&xc)
- defer C.libxl_vsndinfo_dispose(&xc)
+C.libxl_vsndinfo_init(&xc)
+defer C.libxl_vsndinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error {
- x.Backend = C.GoString(xc.backend)
- x.BackendId = uint32(xc.backend_id)
- x.Frontend = C.GoString(xc.frontend)
- x.FrontendId = uint32(xc.frontend_id)
- x.Devid = Devid(xc.devid)
- x.State = int(xc.state)
- x.Pcms = nil
- if n := int(xc.num_vsnd_pcms); n > 0 {
- cPcms := (*[1 << 28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:n:n]
- x.Pcms = make([]Pcminfo, n)
- for i, v := range cPcms {
- if err := x.Pcms[i].fromC(&v); err != nil {
- return fmt.Errorf("converting field Pcms: %v", err)
- }
- }
- }
-
- return nil
-}
-
-func (x *Vsndinfo) toC(xc *C.libxl_vsndinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vsndinfo_dispose(xc)
- }
- }()
-
- if x.Backend != "" {
- xc.backend = C.CString(x.Backend)
- }
- xc.backend_id = C.uint32_t(x.BackendId)
- if x.Frontend != "" {
- xc.frontend = C.CString(x.Frontend)
- }
- xc.frontend_id = C.uint32_t(x.FrontendId)
- xc.devid = C.libxl_devid(x.Devid)
- xc.state = C.int(x.State)
- if numVsndPcms := len(x.Pcms); numVsndPcms > 0 {
- xc.pcms = (*C.libxl_pcminfo)(C.malloc(C.ulong(numVsndPcms) * C.sizeof_libxl_pcminfo))
- xc.num_vsnd_pcms = C.int(numVsndPcms)
- cPcms := (*[1 << 28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms]
- for i, v := range x.Pcms {
- if err := v.toC(&cPcms[i]); err != nil {
- return fmt.Errorf("converting field Pcms: %v", err)
- }
- }
- }
-
- return nil
-}
+ x.Backend = C.GoString(xc.backend)
+x.BackendId = uint32(xc.backend_id)
+x.Frontend = C.GoString(xc.frontend)
+x.FrontendId = uint32(xc.frontend_id)
+x.Devid = Devid(xc.devid)
+x.State = int(xc.state)
+x.Pcms = nil
+if n := int(xc.num_vsnd_pcms); n > 0 {
+cPcms := (*[1<<28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:n:n]
+x.Pcms = make([]Pcminfo, n)
+for i, v := range cPcms {
+if err := x.Pcms[i].fromC(&v); err != nil {
+return fmt.Errorf("converting field Pcms: %v", err) }
+}
+}
+
+ return nil}
+
+func (x *Vsndinfo) toC(xc *C.libxl_vsndinfo) (err error){defer func(){
+if err != nil{
+C.libxl_vsndinfo_dispose(xc)}
+}()
+
+if x.Backend != "" {
+xc.backend = C.CString(x.Backend)}
+xc.backend_id = C.uint32_t(x.BackendId)
+if x.Frontend != "" {
+xc.frontend = C.CString(x.Frontend)}
+xc.frontend_id = C.uint32_t(x.FrontendId)
+xc.devid = C.libxl_devid(x.Devid)
+xc.state = C.int(x.State)
+if numVsndPcms := len(x.Pcms); numVsndPcms > 0 {
+xc.pcms = (*C.libxl_pcminfo)(C.malloc(C.ulong(numVsndPcms)*C.sizeof_libxl_pcminfo))
+xc.num_vsnd_pcms = C.int(numVsndPcms)
+cPcms := (*[1<<28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms]
+for i,v := range x.Pcms {
+if err := v.toC(&cPcms[i]); err != nil {
+return fmt.Errorf("converting field Pcms: %v", err)
+}
+}
+}
+
+ return nil
+ }
// NewVkbinfo returns an instance of Vkbinfo initialized with defaults.
func NewVkbinfo() (*Vkbinfo, error) {
- var (
- x Vkbinfo
- xc C.libxl_vkbinfo
- )
+var (
+x Vkbinfo
+xc C.libxl_vkbinfo)
- C.libxl_vkbinfo_init(&xc)
- defer C.libxl_vkbinfo_dispose(&xc)
+C.libxl_vkbinfo_init(&xc)
+defer C.libxl_vkbinfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error {
- x.Backend = C.GoString(xc.backend)
- x.BackendId = uint32(xc.backend_id)
- x.Frontend = C.GoString(xc.frontend)
- x.FrontendId = uint32(xc.frontend_id)
- x.Devid = Devid(xc.devid)
- x.State = int(xc.state)
- x.Evtch = int(xc.evtch)
- x.Rref = int(xc.rref)
-
- return nil
-}
-
-func (x *Vkbinfo) toC(xc *C.libxl_vkbinfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_vkbinfo_dispose(xc)
- }
- }()
-
- if x.Backend != "" {
- xc.backend = C.CString(x.Backend)
- }
- xc.backend_id = C.uint32_t(x.BackendId)
- if x.Frontend != "" {
- xc.frontend = C.CString(x.Frontend)
- }
- xc.frontend_id = C.uint32_t(x.FrontendId)
- xc.devid = C.libxl_devid(x.Devid)
- xc.state = C.int(x.State)
- xc.evtch = C.int(x.Evtch)
- xc.rref = C.int(x.Rref)
-
- return nil
-}
+ x.Backend = C.GoString(xc.backend)
+x.BackendId = uint32(xc.backend_id)
+x.Frontend = C.GoString(xc.frontend)
+x.FrontendId = uint32(xc.frontend_id)
+x.Devid = Devid(xc.devid)
+x.State = int(xc.state)
+x.Evtch = int(xc.evtch)
+x.Rref = int(xc.rref)
+
+ return nil}
+
+func (x *Vkbinfo) toC(xc *C.libxl_vkbinfo) (err error){defer func(){
+if err != nil{
+C.libxl_vkbinfo_dispose(xc)}
+}()
+
+if x.Backend != "" {
+xc.backend = C.CString(x.Backend)}
+xc.backend_id = C.uint32_t(x.BackendId)
+if x.Frontend != "" {
+xc.frontend = C.CString(x.Frontend)}
+xc.frontend_id = C.uint32_t(x.FrontendId)
+xc.devid = C.libxl_devid(x.Devid)
+xc.state = C.int(x.State)
+xc.evtch = C.int(x.Evtch)
+xc.rref = C.int(x.Rref)
+
+ return nil
+ }
// NewNumainfo returns an instance of Numainfo initialized with defaults.
func NewNumainfo() (*Numainfo, error) {
- var (
- x Numainfo
- xc C.libxl_numainfo
- )
+var (
+x Numainfo
+xc C.libxl_numainfo)
- C.libxl_numainfo_init(&xc)
- defer C.libxl_numainfo_dispose(&xc)
+C.libxl_numainfo_init(&xc)
+defer C.libxl_numainfo_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Numainfo) fromC(xc *C.libxl_numainfo) error {
- x.Size = uint64(xc.size)
- x.Free = uint64(xc.free)
- x.Dists = nil
- if n := int(xc.num_dists); n > 0 {
- cDists := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.dists))[:n:n]
- x.Dists = make([]uint32, n)
- for i, v := range cDists {
- x.Dists[i] = uint32(v)
- }
- }
-
- return nil
-}
-
-func (x *Numainfo) toC(xc *C.libxl_numainfo) (err error) {
- defer func() {
- if err != nil {
- C.libxl_numainfo_dispose(xc)
- }
- }()
-
- xc.size = C.uint64_t(x.Size)
- xc.free = C.uint64_t(x.Free)
- if numDists := len(x.Dists); numDists > 0 {
- xc.dists = (*C.uint32_t)(C.malloc(C.size_t(numDists * numDists)))
- xc.num_dists = C.int(numDists)
- cDists := (*[1 << 28]C.uint32_t)(unsafe.Pointer(xc.dists))[:numDists:numDists]
- for i, v := range x.Dists {
- cDists[i] = C.uint32_t(v)
- }
- }
-
- return nil
+ x.Size = uint64(xc.size)
+x.Free = uint64(xc.free)
+x.Dists = nil
+if n := int(xc.num_dists); n > 0 {
+cDists := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.dists))[:n:n]
+x.Dists = make([]uint32, n)
+for i, v := range cDists {
+x.Dists[i] = uint32(v)
+}
}
+ return nil}
+
+func (x *Numainfo) toC(xc *C.libxl_numainfo) (err error){defer func(){
+if err != nil{
+C.libxl_numainfo_dispose(xc)}
+}()
+
+xc.size = C.uint64_t(x.Size)
+xc.free = C.uint64_t(x.Free)
+if numDists := len(x.Dists); numDists > 0 {
+xc.dists = (*C.uint32_t)(C.malloc(C.size_t(numDists*numDists)))
+xc.num_dists = C.int(numDists)
+cDists := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.dists))[:numDists:numDists]
+for i,v := range x.Dists {
+cDists[i] = C.uint32_t(v)
+}
+}
+
+ return nil
+ }
+
// NewCputopology returns an instance of Cputopology initialized with defaults.
func NewCputopology() (*Cputopology, error) {
- var (
- x Cputopology
- xc C.libxl_cputopology
- )
+var (
+x Cputopology
+xc C.libxl_cputopology)
- C.libxl_cputopology_init(&xc)
- defer C.libxl_cputopology_dispose(&xc)
+C.libxl_cputopology_init(&xc)
+defer C.libxl_cputopology_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Cputopology) fromC(xc *C.libxl_cputopology) error {
- x.Core = uint32(xc.core)
- x.Socket = uint32(xc.socket)
- x.Node = uint32(xc.node)
+ x.Core = uint32(xc.core)
+x.Socket = uint32(xc.socket)
+x.Node = uint32(xc.node)
- return nil
-}
+ return nil}
-func (x *Cputopology) toC(xc *C.libxl_cputopology) (err error) {
- defer func() {
- if err != nil {
- C.libxl_cputopology_dispose(xc)
- }
- }()
+func (x *Cputopology) toC(xc *C.libxl_cputopology) (err error){defer func(){
+if err != nil{
+C.libxl_cputopology_dispose(xc)}
+}()
- xc.core = C.uint32_t(x.Core)
- xc.socket = C.uint32_t(x.Socket)
- xc.node = C.uint32_t(x.Node)
+xc.core = C.uint32_t(x.Core)
+xc.socket = C.uint32_t(x.Socket)
+xc.node = C.uint32_t(x.Node)
- return nil
-}
+ return nil
+ }
// NewPcitopology returns an instance of Pcitopology initialized with defaults.
func NewPcitopology() (*Pcitopology, error) {
- var (
- x Pcitopology
- xc C.libxl_pcitopology
- )
+var (
+x Pcitopology
+xc C.libxl_pcitopology)
- C.libxl_pcitopology_init(&xc)
- defer C.libxl_pcitopology_dispose(&xc)
+C.libxl_pcitopology_init(&xc)
+defer C.libxl_pcitopology_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error {
- x.Seg = uint16(xc.seg)
- x.Bus = byte(xc.bus)
- x.Devfn = byte(xc.devfn)
- x.Node = uint32(xc.node)
+ x.Seg = uint16(xc.seg)
+x.Bus = byte(xc.bus)
+x.Devfn = byte(xc.devfn)
+x.Node = uint32(xc.node)
- return nil
-}
+ return nil}
-func (x *Pcitopology) toC(xc *C.libxl_pcitopology) (err error) {
- defer func() {
- if err != nil {
- C.libxl_pcitopology_dispose(xc)
- }
- }()
+func (x *Pcitopology) toC(xc *C.libxl_pcitopology) (err error){defer func(){
+if err != nil{
+C.libxl_pcitopology_dispose(xc)}
+}()
- xc.seg = C.uint16_t(x.Seg)
- xc.bus = C.uint8_t(x.Bus)
- xc.devfn = C.uint8_t(x.Devfn)
- xc.node = C.uint32_t(x.Node)
+xc.seg = C.uint16_t(x.Seg)
+xc.bus = C.uint8_t(x.Bus)
+xc.devfn = C.uint8_t(x.Devfn)
+xc.node = C.uint32_t(x.Node)
- return nil
-}
+ return nil
+ }
// NewSchedCreditParams returns an instance of SchedCreditParams initialized with defaults.
func NewSchedCreditParams() (*SchedCreditParams, error) {
- var (
- x SchedCreditParams
- xc C.libxl_sched_credit_params
- )
+var (
+x SchedCreditParams
+xc C.libxl_sched_credit_params)
- C.libxl_sched_credit_params_init(&xc)
+C.libxl_sched_credit_params_init(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *SchedCreditParams) fromC(xc *C.libxl_sched_credit_params) error {
- x.TsliceMs = int(xc.tslice_ms)
- x.RatelimitUs = int(xc.ratelimit_us)
- x.VcpuMigrDelayUs = int(xc.vcpu_migr_delay_us)
+ x.TsliceMs = int(xc.tslice_ms)
+x.RatelimitUs = int(xc.ratelimit_us)
+x.VcpuMigrDelayUs = int(xc.vcpu_migr_delay_us)
- return nil
-}
+ return nil}
-func (x *SchedCreditParams) toC(xc *C.libxl_sched_credit_params) (err error) {
- xc.tslice_ms = C.int(x.TsliceMs)
- xc.ratelimit_us = C.int(x.RatelimitUs)
- xc.vcpu_migr_delay_us = C.int(x.VcpuMigrDelayUs)
+func (x *SchedCreditParams) toC(xc *C.libxl_sched_credit_params) (err error){xc.tslice_ms = C.int(x.TsliceMs)
+xc.ratelimit_us = C.int(x.RatelimitUs)
+xc.vcpu_migr_delay_us = C.int(x.VcpuMigrDelayUs)
- return nil
-}
+ return nil
+ }
// NewSchedCredit2Params returns an instance of SchedCredit2Params initialized with defaults.
func NewSchedCredit2Params() (*SchedCredit2Params, error) {
- var (
- x SchedCredit2Params
- xc C.libxl_sched_credit2_params
- )
+var (
+x SchedCredit2Params
+xc C.libxl_sched_credit2_params)
- C.libxl_sched_credit2_params_init(&xc)
+C.libxl_sched_credit2_params_init(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *SchedCredit2Params) fromC(xc *C.libxl_sched_credit2_params) error {
- x.RatelimitUs = int(xc.ratelimit_us)
+ x.RatelimitUs = int(xc.ratelimit_us)
- return nil
-}
+ return nil}
-func (x *SchedCredit2Params) toC(xc *C.libxl_sched_credit2_params) (err error) {
- xc.ratelimit_us = C.int(x.RatelimitUs)
+func (x *SchedCredit2Params) toC(xc *C.libxl_sched_credit2_params) (err error){xc.ratelimit_us = C.int(x.RatelimitUs)
- return nil
-}
+ return nil
+ }
// NewDomainRemusInfo returns an instance of DomainRemusInfo initialized with defaults.
func NewDomainRemusInfo() (*DomainRemusInfo, error) {
- var (
- x DomainRemusInfo
- xc C.libxl_domain_remus_info
- )
+var (
+x DomainRemusInfo
+xc C.libxl_domain_remus_info)
- C.libxl_domain_remus_info_init(&xc)
- defer C.libxl_domain_remus_info_dispose(&xc)
+C.libxl_domain_remus_info_init(&xc)
+defer C.libxl_domain_remus_info_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *DomainRemusInfo) fromC(xc *C.libxl_domain_remus_info) error {
- x.Interval = int(xc.interval)
- if err := x.AllowUnsafe.fromC(&xc.allow_unsafe); err != nil {
- return fmt.Errorf("converting field AllowUnsafe: %v", err)
- }
- if err := x.Blackhole.fromC(&xc.blackhole); err != nil {
- return fmt.Errorf("converting field Blackhole: %v", err)
- }
- if err := x.Compression.fromC(&xc.compression); err != nil {
- return fmt.Errorf("converting field Compression: %v", err)
- }
- if err := x.Netbuf.fromC(&xc.netbuf); err != nil {
- return fmt.Errorf("converting field Netbuf: %v", err)
- }
- x.Netbufscript = C.GoString(xc.netbufscript)
- if err := x.Diskbuf.fromC(&xc.diskbuf); err != nil {
- return fmt.Errorf("converting field Diskbuf: %v", err)
- }
- if err := x.Colo.fromC(&xc.colo); err != nil {
- return fmt.Errorf("converting field Colo: %v", err)
- }
- if err := x.UserspaceColoProxy.fromC(&xc.userspace_colo_proxy); err != nil {
- return fmt.Errorf("converting field UserspaceColoProxy: %v", err)
- }
-
- return nil
-}
-
-func (x *DomainRemusInfo) toC(xc *C.libxl_domain_remus_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_domain_remus_info_dispose(xc)
- }
- }()
-
- xc.interval = C.int(x.Interval)
- if err := x.AllowUnsafe.toC(&xc.allow_unsafe); err != nil {
- return fmt.Errorf("converting field AllowUnsafe: %v", err)
- }
- if err := x.Blackhole.toC(&xc.blackhole); err != nil {
- return fmt.Errorf("converting field Blackhole: %v", err)
- }
- if err := x.Compression.toC(&xc.compression); err != nil {
- return fmt.Errorf("converting field Compression: %v", err)
- }
- if err := x.Netbuf.toC(&xc.netbuf); err != nil {
- return fmt.Errorf("converting field Netbuf: %v", err)
- }
- if x.Netbufscript != "" {
- xc.netbufscript = C.CString(x.Netbufscript)
- }
- if err := x.Diskbuf.toC(&xc.diskbuf); err != nil {
- return fmt.Errorf("converting field Diskbuf: %v", err)
- }
- if err := x.Colo.toC(&xc.colo); err != nil {
- return fmt.Errorf("converting field Colo: %v", err)
- }
- if err := x.UserspaceColoProxy.toC(&xc.userspace_colo_proxy); err != nil {
- return fmt.Errorf("converting field UserspaceColoProxy: %v", err)
- }
-
- return nil
+ x.Interval = int(xc.interval)
+if err := x.AllowUnsafe.fromC(&xc.allow_unsafe);err != nil {
+return fmt.Errorf("converting field AllowUnsafe: %v", err)
+}
+if err := x.Blackhole.fromC(&xc.blackhole);err != nil {
+return fmt.Errorf("converting field Blackhole: %v", err)
}
+if err := x.Compression.fromC(&xc.compression);err != nil {
+return fmt.Errorf("converting field Compression: %v", err)
+}
+if err := x.Netbuf.fromC(&xc.netbuf);err != nil {
+return fmt.Errorf("converting field Netbuf: %v", err)
+}
+x.Netbufscript = C.GoString(xc.netbufscript)
+if err := x.Diskbuf.fromC(&xc.diskbuf);err != nil {
+return fmt.Errorf("converting field Diskbuf: %v", err)
+}
+if err := x.Colo.fromC(&xc.colo);err != nil {
+return fmt.Errorf("converting field Colo: %v", err)
+}
+if err := x.UserspaceColoProxy.fromC(&xc.userspace_colo_proxy);err != nil {
+return fmt.Errorf("converting field UserspaceColoProxy: %v", err)
+}
+
+ return nil}
+
+func (x *DomainRemusInfo) toC(xc *C.libxl_domain_remus_info) (err error){defer func(){
+if err != nil{
+C.libxl_domain_remus_info_dispose(xc)}
+}()
+
+xc.interval = C.int(x.Interval)
+if err := x.AllowUnsafe.toC(&xc.allow_unsafe); err != nil {
+return fmt.Errorf("converting field AllowUnsafe: %v", err)
+}
+if err := x.Blackhole.toC(&xc.blackhole); err != nil {
+return fmt.Errorf("converting field Blackhole: %v", err)
+}
+if err := x.Compression.toC(&xc.compression); err != nil {
+return fmt.Errorf("converting field Compression: %v", err)
+}
+if err := x.Netbuf.toC(&xc.netbuf); err != nil {
+return fmt.Errorf("converting field Netbuf: %v", err)
+}
+if x.Netbufscript != "" {
+xc.netbufscript = C.CString(x.Netbufscript)}
+if err := x.Diskbuf.toC(&xc.diskbuf); err != nil {
+return fmt.Errorf("converting field Diskbuf: %v", err)
+}
+if err := x.Colo.toC(&xc.colo); err != nil {
+return fmt.Errorf("converting field Colo: %v", err)
+}
+if err := x.UserspaceColoProxy.toC(&xc.userspace_colo_proxy); err != nil {
+return fmt.Errorf("converting field UserspaceColoProxy: %v", err)
+}
+
+ return nil
+ }
// NewEvent returns an instance of Event initialized with defaults.
func NewEvent(etype EventType) (*Event, error) {
- var (
- x Event
- xc C.libxl_event
- )
+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)
+C.libxl_event_init(&xc)
+C.libxl_event_init_type(&xc, C.libxl_event_type(etype))
+defer C.libxl_event_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *Event) fromC(xc *C.libxl_event) error {
- if err := x.Link.fromC(&xc.link); err != nil {
- return fmt.Errorf("converting field Link: %v", err)
- }
- x.Domid = Domid(xc.domid)
- if err := x.Domuuid.fromC(&xc.domuuid); err != nil {
- return fmt.Errorf("converting field Domuuid: %v", err)
- }
- x.ForUser = uint64(xc.for_user)
- x.Type = EventType(xc._type)
- switch x.Type {
- case EventTypeDomainShutdown:
- var typeDomainShutdown EventTypeUnionDomainShutdown
- if err := typeDomainShutdown.fromC(xc); err != nil {
- return fmt.Errorf("converting field typeDomainShutdown: %v", err)
- }
- x.TypeUnion = typeDomainShutdown
- case EventTypeDomainDeath:
- x.TypeUnion = nil
- case EventTypeDiskEject:
- var typeDiskEject EventTypeUnionDiskEject
- if err := typeDiskEject.fromC(xc); err != nil {
- return fmt.Errorf("converting field typeDiskEject: %v", err)
- }
- x.TypeUnion = typeDiskEject
- case EventTypeOperationComplete:
- var typeOperationComplete EventTypeUnionOperationComplete
- if err := typeOperationComplete.fromC(xc); err != nil {
- return fmt.Errorf("converting field typeOperationComplete: %v", err)
- }
- x.TypeUnion = typeOperationComplete
- case EventTypeDomainCreateConsoleAvailable:
- x.TypeUnion = nil
- default:
- return fmt.Errorf("invalid union key '%v'", x.Type)
- }
-
- return nil
-}
+ if err := x.Link.fromC(&xc.link);err != nil {
+return fmt.Errorf("converting field Link: %v", err)
+}
+x.Domid = Domid(xc.domid)
+if err := x.Domuuid.fromC(&xc.domuuid);err != nil {
+return fmt.Errorf("converting field Domuuid: %v", err)
+}
+x.ForUser = uint64(xc.for_user)
+x.Type = EventType(xc._type)
+switch x.Type{
+case EventTypeDomainShutdown:
+var typeDomainShutdown EventTypeUnionDomainShutdown
+if err := typeDomainShutdown.fromC(xc);err != nil {
+ return fmt.Errorf("converting field typeDomainShutdown: %v", err)
+}
+x.TypeUnion = typeDomainShutdown
+case EventTypeDomainDeath:
+x.TypeUnion = nil
+case EventTypeDiskEject:
+var typeDiskEject EventTypeUnionDiskEject
+if err := typeDiskEject.fromC(xc);err != nil {
+ return fmt.Errorf("converting field typeDiskEject: %v", err)
+}
+x.TypeUnion = typeDiskEject
+case EventTypeOperationComplete:
+var typeOperationComplete EventTypeUnionOperationComplete
+if err := typeOperationComplete.fromC(xc);err != nil {
+ return fmt.Errorf("converting field typeOperationComplete: %v", err)
+}
+x.TypeUnion = typeOperationComplete
+case EventTypeDomainCreateConsoleAvailable:
+x.TypeUnion = nil
+default:
+return fmt.Errorf("invalid union key '%v'", x.Type)}
+
+ return nil}
func (x *EventTypeUnionDomainShutdown) fromC(xc *C.libxl_event) error {
- if EventType(xc._type) != EventTypeDomainShutdown {
- return errors.New("expected union key EventTypeDomainShutdown")
- }
+if EventType(xc._type) != EventTypeDomainShutdown {
+return errors.New("expected union key EventTypeDomainShutdown")
+}
- tmp := (*C.libxl_event_type_union_domain_shutdown)(unsafe.Pointer(&xc.u[0]))
- x.ShutdownReason = byte(tmp.shutdown_reason)
- return nil
+tmp := (*C.libxl_event_type_union_domain_shutdown)(unsafe.Pointer(&xc.u[0]))
+x.ShutdownReason = byte(tmp.shutdown_reason)
+return nil
}
func (x *EventTypeUnionDiskEject) fromC(xc *C.libxl_event) error {
- if EventType(xc._type) != EventTypeDiskEject {
- return errors.New("expected union key EventTypeDiskEject")
- }
+if EventType(xc._type) != EventTypeDiskEject {
+return errors.New("expected union key EventTypeDiskEject")
+}
- tmp := (*C.libxl_event_type_union_disk_eject)(unsafe.Pointer(&xc.u[0]))
- x.Vdev = C.GoString(tmp.vdev)
- if err := x.Disk.fromC(&tmp.disk); err != nil {
- return fmt.Errorf("converting field Disk: %v", err)
- }
- return nil
+tmp := (*C.libxl_event_type_union_disk_eject)(unsafe.Pointer(&xc.u[0]))
+x.Vdev = C.GoString(tmp.vdev)
+if err := x.Disk.fromC(&tmp.disk);err != nil {
+return fmt.Errorf("converting field Disk: %v", err)
+}
+return nil
}
func (x *EventTypeUnionOperationComplete) fromC(xc *C.libxl_event) error {
- if EventType(xc._type) != EventTypeOperationComplete {
- return errors.New("expected union key EventTypeOperationComplete")
- }
-
- tmp := (*C.libxl_event_type_union_operation_complete)(unsafe.Pointer(&xc.u[0]))
- x.Rc = int(tmp.rc)
- return nil
-}
-
-func (x *Event) toC(xc *C.libxl_event) (err error) {
- defer func() {
- if err != nil {
- C.libxl_event_dispose(xc)
- }
- }()
-
- if err := x.Link.toC(&xc.link); err != nil {
- return fmt.Errorf("converting field Link: %v", err)
- }
- xc.domid = C.libxl_domid(x.Domid)
- if err := x.Domuuid.toC(&xc.domuuid); err != nil {
- return fmt.Errorf("converting field Domuuid: %v", err)
- }
- xc.for_user = C.uint64_t(x.ForUser)
- xc._type = C.libxl_event_type(x.Type)
- switch x.Type {
- case EventTypeDomainShutdown:
- tmp, ok := x.TypeUnion.(EventTypeUnionDomainShutdown)
- if !ok {
- return errors.New("wrong type for union key type")
- }
- var domain_shutdown C.libxl_event_type_union_domain_shutdown
- domain_shutdown.shutdown_reason = C.uint8_t(tmp.ShutdownReason)
- domain_shutdownBytes := C.GoBytes(unsafe.Pointer(&domain_shutdown), C.sizeof_libxl_event_type_union_domain_shutdown)
- copy(xc.u[:], domain_shutdownBytes)
- case EventTypeDomainDeath:
- break
- case EventTypeDiskEject:
- tmp, ok := x.TypeUnion.(EventTypeUnionDiskEject)
- if !ok {
- return errors.New("wrong type for union key type")
- }
- var disk_eject C.libxl_event_type_union_disk_eject
- if tmp.Vdev != "" {
- disk_eject.vdev = C.CString(tmp.Vdev)
- }
- if err := tmp.Disk.toC(&disk_eject.disk); err != nil {
- return fmt.Errorf("converting field Disk: %v", err)
- }
- disk_ejectBytes := C.GoBytes(unsafe.Pointer(&disk_eject), C.sizeof_libxl_event_type_union_disk_eject)
- copy(xc.u[:], disk_ejectBytes)
- case EventTypeOperationComplete:
- tmp, ok := x.TypeUnion.(EventTypeUnionOperationComplete)
- if !ok {
- return errors.New("wrong type for union key type")
- }
- var operation_complete C.libxl_event_type_union_operation_complete
- operation_complete.rc = C.int(tmp.Rc)
- operation_completeBytes := C.GoBytes(unsafe.Pointer(&operation_complete), C.sizeof_libxl_event_type_union_operation_complete)
- copy(xc.u[:], operation_completeBytes)
- case EventTypeDomainCreateConsoleAvailable:
- break
- default:
- return fmt.Errorf("invalid union key '%v'", x.Type)
- }
-
- return nil
-}
+if EventType(xc._type) != EventTypeOperationComplete {
+return errors.New("expected union key EventTypeOperationComplete")
+}
+
+tmp := (*C.libxl_event_type_union_operation_complete)(unsafe.Pointer(&xc.u[0]))
+x.Rc = int(tmp.rc)
+return nil
+}
+
+func (x *Event) toC(xc *C.libxl_event) (err error){defer func(){
+if err != nil{
+C.libxl_event_dispose(xc)}
+}()
+
+if err := x.Link.toC(&xc.link); err != nil {
+return fmt.Errorf("converting field Link: %v", err)
+}
+xc.domid = C.libxl_domid(x.Domid)
+if err := x.Domuuid.toC(&xc.domuuid); err != nil {
+return fmt.Errorf("converting field Domuuid: %v", err)
+}
+xc.for_user = C.uint64_t(x.ForUser)
+xc._type = C.libxl_event_type(x.Type)
+switch x.Type{
+case EventTypeDomainShutdown:
+tmp, ok := x.TypeUnion.(EventTypeUnionDomainShutdown)
+if !ok {
+return errors.New("wrong type for union key type")
+}
+var domain_shutdown C.libxl_event_type_union_domain_shutdown
+domain_shutdown.shutdown_reason = C.uint8_t(tmp.ShutdownReason)
+domain_shutdownBytes := C.GoBytes(unsafe.Pointer(&domain_shutdown),C.sizeof_libxl_event_type_union_domain_shutdown)
+copy(xc.u[:],domain_shutdownBytes)
+case EventTypeDomainDeath:
+break
+case EventTypeDiskEject:
+tmp, ok := x.TypeUnion.(EventTypeUnionDiskEject)
+if !ok {
+return errors.New("wrong type for union key type")
+}
+var disk_eject C.libxl_event_type_union_disk_eject
+if tmp.Vdev != "" {
+disk_eject.vdev = C.CString(tmp.Vdev)}
+if err := tmp.Disk.toC(&disk_eject.disk); err != nil {
+return fmt.Errorf("converting field Disk: %v", err)
+}
+disk_ejectBytes := C.GoBytes(unsafe.Pointer(&disk_eject),C.sizeof_libxl_event_type_union_disk_eject)
+copy(xc.u[:],disk_ejectBytes)
+case EventTypeOperationComplete:
+tmp, ok := x.TypeUnion.(EventTypeUnionOperationComplete)
+if !ok {
+return errors.New("wrong type for union key type")
+}
+var operation_complete C.libxl_event_type_union_operation_complete
+operation_complete.rc = C.int(tmp.Rc)
+operation_completeBytes := C.GoBytes(unsafe.Pointer(&operation_complete),C.sizeof_libxl_event_type_union_operation_complete)
+copy(xc.u[:],operation_completeBytes)
+case EventTypeDomainCreateConsoleAvailable:
+break
+default:
+return fmt.Errorf("invalid union key '%v'", x.Type)}
+
+ return nil
+ }
// NewPsrCatInfo returns an instance of PsrCatInfo initialized with defaults.
func NewPsrCatInfo() (*PsrCatInfo, error) {
- var (
- x PsrCatInfo
- xc C.libxl_psr_cat_info
- )
+var (
+x PsrCatInfo
+xc C.libxl_psr_cat_info)
- C.libxl_psr_cat_info_init(&xc)
- defer C.libxl_psr_cat_info_dispose(&xc)
+C.libxl_psr_cat_info_init(&xc)
+defer C.libxl_psr_cat_info_dispose(&xc)
- if err := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *PsrCatInfo) fromC(xc *C.libxl_psr_cat_info) error {
- x.Id = uint32(xc.id)
- x.CosMax = uint32(xc.cos_max)
- x.CbmLen = uint32(xc.cbm_len)
- x.CdpEnabled = bool(xc.cdp_enabled)
+ x.Id = uint32(xc.id)
+x.CosMax = uint32(xc.cos_max)
+x.CbmLen = uint32(xc.cbm_len)
+x.CdpEnabled = bool(xc.cdp_enabled)
- return nil
-}
+ return nil}
-func (x *PsrCatInfo) toC(xc *C.libxl_psr_cat_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_psr_cat_info_dispose(xc)
- }
- }()
+func (x *PsrCatInfo) toC(xc *C.libxl_psr_cat_info) (err error){defer func(){
+if err != nil{
+C.libxl_psr_cat_info_dispose(xc)}
+}()
- xc.id = C.uint32_t(x.Id)
- xc.cos_max = C.uint32_t(x.CosMax)
- xc.cbm_len = C.uint32_t(x.CbmLen)
- xc.cdp_enabled = C.bool(x.CdpEnabled)
+xc.id = C.uint32_t(x.Id)
+xc.cos_max = C.uint32_t(x.CosMax)
+xc.cbm_len = C.uint32_t(x.CbmLen)
+xc.cdp_enabled = C.bool(x.CdpEnabled)
- return nil
-}
+ return nil
+ }
// NewPsrHwInfo returns an instance of PsrHwInfo initialized with defaults.
func NewPsrHwInfo(ptype PsrFeatType) (*PsrHwInfo, error) {
- var (
- x PsrHwInfo
- xc C.libxl_psr_hw_info
- )
+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)
+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 := x.fromC(&xc); err != nil {
- return nil, err
- }
+if err := x.fromC(&xc); err != nil {
+return nil, err }
- return &x, nil
-}
+return &x, nil}
func (x *PsrHwInfo) fromC(xc *C.libxl_psr_hw_info) error {
- x.Id = uint32(xc.id)
- x.Type = PsrFeatType(xc._type)
- switch x.Type {
- case PsrFeatTypeCat:
- var typeCat PsrHwInfoTypeUnionCat
- if err := typeCat.fromC(xc); err != nil {
- return fmt.Errorf("converting field typeCat: %v", err)
- }
- x.TypeUnion = typeCat
- case PsrFeatTypeMba:
- var typeMba PsrHwInfoTypeUnionMba
- if err := typeMba.fromC(xc); err != nil {
- return fmt.Errorf("converting field typeMba: %v", err)
- }
- x.TypeUnion = typeMba
- default:
- return fmt.Errorf("invalid union key '%v'", x.Type)
- }
-
- return nil
-}
+ x.Id = uint32(xc.id)
+x.Type = PsrFeatType(xc._type)
+switch x.Type{
+case PsrFeatTypeCat:
+var typeCat PsrHwInfoTypeUnionCat
+if err := typeCat.fromC(xc);err != nil {
+ return fmt.Errorf("converting field typeCat: %v", err)
+}
+x.TypeUnion = typeCat
+case PsrFeatTypeMba:
+var typeMba PsrHwInfoTypeUnionMba
+if err := typeMba.fromC(xc);err != nil {
+ return fmt.Errorf("converting field typeMba: %v", err)
+}
+x.TypeUnion = typeMba
+default:
+return fmt.Errorf("invalid union key '%v'", x.Type)}
+
+ return nil}
func (x *PsrHwInfoTypeUnionCat) fromC(xc *C.libxl_psr_hw_info) error {
- if PsrFeatType(xc._type) != PsrFeatTypeCat {
- return errors.New("expected union key PsrFeatTypeCat")
- }
+if PsrFeatType(xc._type) != PsrFeatTypeCat {
+return errors.New("expected union key PsrFeatTypeCat")
+}
- tmp := (*C.libxl_psr_hw_info_type_union_cat)(unsafe.Pointer(&xc.u[0]))
- x.CosMax = uint32(tmp.cos_max)
- x.CbmLen = uint32(tmp.cbm_len)
- x.CdpEnabled = bool(tmp.cdp_enabled)
- return nil
+tmp := (*C.libxl_psr_hw_info_type_union_cat)(unsafe.Pointer(&xc.u[0]))
+x.CosMax = uint32(tmp.cos_max)
+x.CbmLen = uint32(tmp.cbm_len)
+x.CdpEnabled = bool(tmp.cdp_enabled)
+return nil
}
func (x *PsrHwInfoTypeUnionMba) fromC(xc *C.libxl_psr_hw_info) error {
- if PsrFeatType(xc._type) != PsrFeatTypeMba {
- return errors.New("expected union key PsrFeatTypeMba")
- }
-
- tmp := (*C.libxl_psr_hw_info_type_union_mba)(unsafe.Pointer(&xc.u[0]))
- x.CosMax = uint32(tmp.cos_max)
- x.ThrtlMax = uint32(tmp.thrtl_max)
- x.Linear = bool(tmp.linear)
- return nil
-}
-
-func (x *PsrHwInfo) toC(xc *C.libxl_psr_hw_info) (err error) {
- defer func() {
- if err != nil {
- C.libxl_psr_hw_info_dispose(xc)
- }
- }()
-
- xc.id = C.uint32_t(x.Id)
- xc._type = C.libxl_psr_feat_type(x.Type)
- switch x.Type {
- case PsrFeatTypeCat:
- tmp, ok := x.TypeUnion.(PsrHwInfoTypeUnionCat)
- if !ok {
- return errors.New("wrong type for union key type")
- }
- var cat C.libxl_psr_hw_info_type_union_cat
- cat.cos_max = C.uint32_t(tmp.CosMax)
- cat.cbm_len = C.uint32_t(tmp.CbmLen)
- cat.cdp_enabled = C.bool(tmp.CdpEnabled)
- catBytes := C.GoBytes(unsafe.Pointer(&cat), C.sizeof_libxl_psr_hw_info_type_union_cat)
- copy(xc.u[:], catBytes)
- case PsrFeatTypeMba:
- tmp, ok := x.TypeUnion.(PsrHwInfoTypeUnionMba)
- if !ok {
- return errors.New("wrong type for union key type")
- }
- var mba C.libxl_psr_hw_info_type_union_mba
- mba.cos_max = C.uint32_t(tmp.CosMax)
- mba.thrtl_max = C.uint32_t(tmp.ThrtlMax)
- mba.linear = C.bool(tmp.Linear)
- mbaBytes := C.GoBytes(unsafe.Pointer(&mba), C.sizeof_libxl_psr_hw_info_type_union_mba)
- copy(xc.u[:], mbaBytes)
- default:
- return fmt.Errorf("invalid union key '%v'", x.Type)
- }
-
- return nil
-}
+if PsrFeatType(xc._type) != PsrFeatTypeMba {
+return errors.New("expected union key PsrFeatTypeMba")
+}
+
+tmp := (*C.libxl_psr_hw_info_type_union_mba)(unsafe.Pointer(&xc.u[0]))
+x.CosMax = uint32(tmp.cos_max)
+x.ThrtlMax = uint32(tmp.thrtl_max)
+x.Linear = bool(tmp.linear)
+return nil
+}
+
+func (x *PsrHwInfo) toC(xc *C.libxl_psr_hw_info) (err error){defer func(){
+if err != nil{
+C.libxl_psr_hw_info_dispose(xc)}
+}()
+
+xc.id = C.uint32_t(x.Id)
+xc._type = C.libxl_psr_feat_type(x.Type)
+switch x.Type{
+case PsrFeatTypeCat:
+tmp, ok := x.TypeUnion.(PsrHwInfoTypeUnionCat)
+if !ok {
+return errors.New("wrong type for union key type")
+}
+var cat C.libxl_psr_hw_info_type_union_cat
+cat.cos_max = C.uint32_t(tmp.CosMax)
+cat.cbm_len = C.uint32_t(tmp.CbmLen)
+cat.cdp_enabled = C.bool(tmp.CdpEnabled)
+catBytes := C.GoBytes(unsafe.Pointer(&cat),C.sizeof_libxl_psr_hw_info_type_union_cat)
+copy(xc.u[:],catBytes)
+case PsrFeatTypeMba:
+tmp, ok := x.TypeUnion.(PsrHwInfoTypeUnionMba)
+if !ok {
+return errors.New("wrong type for union key type")
+}
+var mba C.libxl_psr_hw_info_type_union_mba
+mba.cos_max = C.uint32_t(tmp.CosMax)
+mba.thrtl_max = C.uint32_t(tmp.ThrtlMax)
+mba.linear = C.bool(tmp.Linear)
+mbaBytes := C.GoBytes(unsafe.Pointer(&mba),C.sizeof_libxl_psr_hw_info_type_union_mba)
+copy(xc.u[:],mbaBytes)
+default:
+return fmt.Errorf("invalid union key '%v'", x.Type)}
+
+ return nil
+ }
+
projects / people / hx242 / xen.git / commitdiff