Lines Matching refs:xc
36 xc C.libxl_ioport_range)
38 C.libxl_ioport_range_init(&xc)
39 defer C.libxl_ioport_range_dispose(&xc)
41 if err := x.fromC(&xc); err != nil {
46 func (x *IoportRange) fromC(xc *C.libxl_ioport_range) error {
47 x.First = uint32(xc.first)
48 x.Number = uint32(xc.number)
52 func (x *IoportRange) toC(xc *C.libxl_ioport_range) (err error){defer func(){
54 C.libxl_ioport_range_dispose(xc)}
57 xc.first = C.uint32_t(x.First)
58 xc.number = C.uint32_t(x.Number)
67 xc C.libxl_iomem_range)
69 C.libxl_iomem_range_init(&xc)
70 defer C.libxl_iomem_range_dispose(&xc)
72 if err := x.fromC(&xc); err != nil {
77 func (x *IomemRange) fromC(xc *C.libxl_iomem_range) error {
78 x.Start = uint64(xc.start)
79 x.Number = uint64(xc.number)
80 x.Gfn = uint64(xc.gfn)
84 func (x *IomemRange) toC(xc *C.libxl_iomem_range) (err error){defer func(){
86 C.libxl_iomem_range_dispose(xc)}
89 xc.start = C.uint64_t(x.Start)
90 xc.number = C.uint64_t(x.Number)
91 xc.gfn = C.uint64_t(x.Gfn)
100 xc C.libxl_vga_interface_info)
102 C.libxl_vga_interface_info_init(&xc)
103 defer C.libxl_vga_interface_info_dispose(&xc)
105 if err := x.fromC(&xc); err != nil {
110 func (x *VgaInterfaceInfo) fromC(xc *C.libxl_vga_interface_info) error {
111 x.Kind = VgaInterfaceType(xc.kind)
115 func (x *VgaInterfaceInfo) toC(xc *C.libxl_vga_interface_info) (err error){defer func(){
117 C.libxl_vga_interface_info_dispose(xc)}
120 xc.kind = C.libxl_vga_interface_type(x.Kind)
129 xc C.libxl_vnc_info)
131 C.libxl_vnc_info_init(&xc)
132 defer C.libxl_vnc_info_dispose(&xc)
134 if err := x.fromC(&xc); err != nil {
139 func (x *VncInfo) fromC(xc *C.libxl_vnc_info) error {
140 if err := x.Enable.fromC(&xc.enable);err != nil {
143 x.Listen = C.GoString(xc.listen)
144 x.Passwd = C.GoString(xc.passwd)
145 x.Display = int(xc.display)
146 if err := x.Findunused.fromC(&xc.findunused);err != nil {
152 func (x *VncInfo) toC(xc *C.libxl_vnc_info) (err error){defer func(){
154 C.libxl_vnc_info_dispose(xc)}
157 if err := x.Enable.toC(&xc.enable); err != nil {
161 xc.listen = C.CString(x.Listen)}
163 xc.passwd = C.CString(x.Passwd)}
164 xc.display = C.int(x.Display)
165 if err := x.Findunused.toC(&xc.findunused); err != nil {
176 xc C.libxl_spice_info)
178 C.libxl_spice_info_init(&xc)
179 defer C.libxl_spice_info_dispose(&xc)
181 if err := x.fromC(&xc); err != nil {
186 func (x *SpiceInfo) fromC(xc *C.libxl_spice_info) error {
187 if err := x.Enable.fromC(&xc.enable);err != nil {
190 x.Port = int(xc.port)
191 x.TlsPort = int(xc.tls_port)
192 x.Host = C.GoString(xc.host)
193 if err := x.DisableTicketing.fromC(&xc.disable_ticketing);err != nil {
196 x.Passwd = C.GoString(xc.passwd)
197 if err := x.AgentMouse.fromC(&xc.agent_mouse);err != nil {
200 if err := x.Vdagent.fromC(&xc.vdagent);err != nil {
203 if err := x.ClipboardSharing.fromC(&xc.clipboard_sharing);err != nil {
206 x.Usbredirection = int(xc.usbredirection)
207 x.ImageCompression = C.GoString(xc.image_compression)
208 x.StreamingVideo = C.GoString(xc.streaming_video)
212 func (x *SpiceInfo) toC(xc *C.libxl_spice_info) (err error){defer func(){
214 C.libxl_spice_info_dispose(xc)}
217 if err := x.Enable.toC(&xc.enable); err != nil {
220 xc.port = C.int(x.Port)
221 xc.tls_port = C.int(x.TlsPort)
223 xc.host = C.CString(x.Host)}
224 if err := x.DisableTicketing.toC(&xc.disable_ticketing); err != nil {
228 xc.passwd = C.CString(x.Passwd)}
229 if err := x.AgentMouse.toC(&xc.agent_mouse); err != nil {
232 if err := x.Vdagent.toC(&xc.vdagent); err != nil {
235 if err := x.ClipboardSharing.toC(&xc.clipboard_sharing); err != nil {
238 xc.usbredirection = C.int(x.Usbredirection)
240 xc.image_compression = C.CString(x.ImageCompression)}
242 xc.streaming_video = C.CString(x.StreamingVideo)}
251 xc C.libxl_sdl_info)
253 C.libxl_sdl_info_init(&xc)
254 defer C.libxl_sdl_info_dispose(&xc)
256 if err := x.fromC(&xc); err != nil {
261 func (x *SdlInfo) fromC(xc *C.libxl_sdl_info) error {
262 if err := x.Enable.fromC(&xc.enable);err != nil {
265 if err := x.Opengl.fromC(&xc.opengl);err != nil {
268 x.Display = C.GoString(xc.display)
269 x.Xauthority = C.GoString(xc.xauthority)
273 func (x *SdlInfo) toC(xc *C.libxl_sdl_info) (err error){defer func(){
275 C.libxl_sdl_info_dispose(xc)}
278 if err := x.Enable.toC(&xc.enable); err != nil {
281 if err := x.Opengl.toC(&xc.opengl); err != nil {
285 xc.display = C.CString(x.Display)}
287 xc.xauthority = C.CString(x.Xauthority)}
296 xc C.libxl_dominfo)
298 C.libxl_dominfo_init(&xc)
299 defer C.libxl_dominfo_dispose(&xc)
301 if err := x.fromC(&xc); err != nil {
306 func (x *Dominfo) fromC(xc *C.libxl_dominfo) error {
307 if err := x.Uuid.fromC(&xc.uuid);err != nil {
310 x.Domid = Domid(xc.domid)
311 x.Ssidref = uint32(xc.ssidref)
312 x.SsidLabel = C.GoString(xc.ssid_label)
313 x.Running = bool(xc.running)
314 x.Blocked = bool(xc.blocked)
315 x.Paused = bool(xc.paused)
316 x.Shutdown = bool(xc.shutdown)
317 x.Dying = bool(xc.dying)
318 x.NeverStop = bool(xc.never_stop)
319 x.ShutdownReason = ShutdownReason(xc.shutdown_reason)
320 x.OutstandingMemkb = uint64(xc.outstanding_memkb)
321 x.CurrentMemkb = uint64(xc.current_memkb)
322 x.SharedMemkb = uint64(xc.shared_memkb)
323 x.PagedMemkb = uint64(xc.paged_memkb)
324 x.MaxMemkb = uint64(xc.max_memkb)
325 x.CpuTime = uint64(xc.cpu_time)
326 x.VcpuMaxId = uint32(xc.vcpu_max_id)
327 x.VcpuOnline = uint32(xc.vcpu_online)
328 x.Cpupool = uint32(xc.cpupool)
329 x.DomainType = DomainType(xc.domain_type)
333 func (x *Dominfo) toC(xc *C.libxl_dominfo) (err error){defer func(){
335 C.libxl_dominfo_dispose(xc)}
338 if err := x.Uuid.toC(&xc.uuid); err != nil {
341 xc.domid = C.libxl_domid(x.Domid)
342 xc.ssidref = C.uint32_t(x.Ssidref)
344 xc.ssid_label = C.CString(x.SsidLabel)}
345 xc.running = C.bool(x.Running)
346 xc.blocked = C.bool(x.Blocked)
347 xc.paused = C.bool(x.Paused)
348 xc.shutdown = C.bool(x.Shutdown)
349 xc.dying = C.bool(x.Dying)
350 xc.never_stop = C.bool(x.NeverStop)
351 xc.shutdown_reason = C.libxl_shutdown_reason(x.ShutdownReason)
352 xc.outstanding_memkb = C.uint64_t(x.OutstandingMemkb)
353 xc.current_memkb = C.uint64_t(x.CurrentMemkb)
354 xc.shared_memkb = C.uint64_t(x.SharedMemkb)
355 xc.paged_memkb = C.uint64_t(x.PagedMemkb)
356 xc.max_memkb = C.uint64_t(x.MaxMemkb)
357 xc.cpu_time = C.uint64_t(x.CpuTime)
358 xc.vcpu_max_id = C.uint32_t(x.VcpuMaxId)
359 xc.vcpu_online = C.uint32_t(x.VcpuOnline)
360 xc.cpupool = C.uint32_t(x.Cpupool)
361 xc.domain_type = C.libxl_domain_type(x.DomainType)
370 xc C.libxl_cpupoolinfo)
372 C.libxl_cpupoolinfo_init(&xc)
373 defer C.libxl_cpupoolinfo_dispose(&xc)
375 if err := x.fromC(&xc); err != nil {
380 func (x *Cpupoolinfo) fromC(xc *C.libxl_cpupoolinfo) error {
381 x.Poolid = uint32(xc.poolid)
382 x.PoolName = C.GoString(xc.pool_name)
383 x.Sched = Scheduler(xc.sched)
384 x.NDom = uint32(xc.n_dom)
385 if err := x.Cpumap.fromC(&xc.cpumap);err != nil {
391 func (x *Cpupoolinfo) toC(xc *C.libxl_cpupoolinfo) (err error){defer func(){
393 C.libxl_cpupoolinfo_dispose(xc)}
396 xc.poolid = C.uint32_t(x.Poolid)
398 xc.pool_name = C.CString(x.PoolName)}
399 xc.sched = C.libxl_scheduler(x.Sched)
400 xc.n_dom = C.uint32_t(x.NDom)
401 if err := x.Cpumap.toC(&xc.cpumap); err != nil {
412 xc C.libxl_channelinfo)
414 C.libxl_channelinfo_init(&xc)
415 C.libxl_channelinfo_init_connection(&xc, C.libxl_channel_connection(connection))
416 defer C.libxl_channelinfo_dispose(&xc)
418 if err := x.fromC(&xc); err != nil {
423 func (x *Channelinfo) fromC(xc *C.libxl_channelinfo) error {
424 x.Backend = C.GoString(xc.backend)
425 x.BackendId = uint32(xc.backend_id)
426 x.Frontend = C.GoString(xc.frontend)
427 x.FrontendId = uint32(xc.frontend_id)
428 x.Devid = Devid(xc.devid)
429 x.State = int(xc.state)
430 x.Evtch = int(xc.evtch)
431 x.Rref = int(xc.rref)
432 x.Connection = ChannelConnection(xc.connection)
436 if err := connectionPty.fromC(xc);err != nil {
449 func (x *ChannelinfoConnectionUnionPty) fromC(xc *C.libxl_channelinfo) error {
450 if ChannelConnection(xc.connection) != ChannelConnectionPty {
454 tmp := (*C.libxl_channelinfo_connection_union_pty)(unsafe.Pointer(&xc.u[0]))
459 func (x *Channelinfo) toC(xc *C.libxl_channelinfo) (err error){defer func(){
461 C.libxl_channelinfo_dispose(xc)}
465 xc.backend = C.CString(x.Backend)}
466 xc.backend_id = C.uint32_t(x.BackendId)
468 xc.frontend = C.CString(x.Frontend)}
469 xc.frontend_id = C.uint32_t(x.FrontendId)
470 xc.devid = C.libxl_devid(x.Devid)
471 xc.state = C.int(x.State)
472 xc.evtch = C.int(x.Evtch)
473 xc.rref = C.int(x.Rref)
474 xc.connection = C.libxl_channel_connection(x.Connection)
487 copy(xc.u[:],ptyBytes)
500 xc C.libxl_vminfo)
502 C.libxl_vminfo_init(&xc)
503 defer C.libxl_vminfo_dispose(&xc)
505 if err := x.fromC(&xc); err != nil {
510 func (x *Vminfo) fromC(xc *C.libxl_vminfo) error {
511 if err := x.Uuid.fromC(&xc.uuid);err != nil {
514 x.Domid = Domid(xc.domid)
518 func (x *Vminfo) toC(xc *C.libxl_vminfo) (err error){defer func(){
520 C.libxl_vminfo_dispose(xc)}
523 if err := x.Uuid.toC(&xc.uuid); err != nil {
526 xc.domid = C.libxl_domid(x.Domid)
535 xc C.libxl_version_info)
537 C.libxl_version_info_init(&xc)
538 defer C.libxl_version_info_dispose(&xc)
540 if err := x.fromC(&xc); err != nil {
545 func (x *VersionInfo) fromC(xc *C.libxl_version_info) error {
546 x.XenVersionMajor = int(xc.xen_version_major)
547 x.XenVersionMinor = int(xc.xen_version_minor)
548 x.XenVersionExtra = C.GoString(xc.xen_version_extra)
549 x.Compiler = C.GoString(xc.compiler)
550 x.CompileBy = C.GoString(xc.compile_by)
551 x.CompileDomain = C.GoString(xc.compile_domain)
552 x.CompileDate = C.GoString(xc.compile_date)
553 x.Capabilities = C.GoString(xc.capabilities)
554 x.Changeset = C.GoString(xc.changeset)
555 x.VirtStart = uint64(xc.virt_start)
556 x.Pagesize = int(xc.pagesize)
557 x.Commandline = C.GoString(xc.commandline)
558 x.BuildId = C.GoString(xc.build_id)
562 func (x *VersionInfo) toC(xc *C.libxl_version_info) (err error){defer func(){
564 C.libxl_version_info_dispose(xc)}
567 xc.xen_version_major = C.int(x.XenVersionMajor)
568 xc.xen_version_minor = C.int(x.XenVersionMinor)
570 xc.xen_version_extra = C.CString(x.XenVersionExtra)}
572 xc.compiler = C.CString(x.Compiler)}
574 xc.compile_by = C.CString(x.CompileBy)}
576 xc.compile_domain = C.CString(x.CompileDomain)}
578 xc.compile_date = C.CString(x.CompileDate)}
580 xc.capabilities = C.CString(x.Capabilities)}
582 xc.changeset = C.CString(x.Changeset)}
583 xc.virt_start = C.uint64_t(x.VirtStart)
584 xc.pagesize = C.int(x.Pagesize)
586 xc.commandline = C.CString(x.Commandline)}
588 xc.build_id = C.CString(x.BuildId)}
597 xc C.libxl_domain_create_info)
599 C.libxl_domain_create_info_init(&xc)
600 defer C.libxl_domain_create_info_dispose(&xc)
602 if err := x.fromC(&xc); err != nil {
607 func (x *DomainCreateInfo) fromC(xc *C.libxl_domain_create_info) error {
608 x.Type = DomainType(xc._type)
609 if err := x.Hap.fromC(&xc.hap);err != nil {
612 if err := x.Oos.fromC(&xc.oos);err != nil {
615 x.Ssidref = uint32(xc.ssidref)
616 x.SsidLabel = C.GoString(xc.ssid_label)
617 x.Name = C.GoString(xc.name)
618 x.Domid = Domid(xc.domid)
619 if err := x.Uuid.fromC(&xc.uuid);err != nil {
622 if err := x.Xsdata.fromC(&xc.xsdata);err != nil {
625 if err := x.Platformdata.fromC(&xc.platformdata);err != nil {
628 x.Poolid = uint32(xc.poolid)
629 x.PoolName = C.GoString(xc.pool_name)
630 if err := x.RunHotplugScripts.fromC(&xc.run_hotplug_scripts);err != nil {
633 if err := x.DriverDomain.fromC(&xc.driver_domain);err != nil {
636 x.Passthrough = Passthrough(xc.passthrough)
637 if err := x.XendSuspendEvtchnCompat.fromC(&xc.xend_suspend_evtchn_compat);err != nil {
643 func (x *DomainCreateInfo) toC(xc *C.libxl_domain_create_info) (err error){defer func(){
645 C.libxl_domain_create_info_dispose(xc)}
648 xc._type = C.libxl_domain_type(x.Type)
649 if err := x.Hap.toC(&xc.hap); err != nil {
652 if err := x.Oos.toC(&xc.oos); err != nil {
655 xc.ssidref = C.uint32_t(x.Ssidref)
657 xc.ssid_label = C.CString(x.SsidLabel)}
659 xc.name = C.CString(x.Name)}
660 xc.domid = C.libxl_domid(x.Domid)
661 if err := x.Uuid.toC(&xc.uuid); err != nil {
664 if err := x.Xsdata.toC(&xc.xsdata); err != nil {
667 if err := x.Platformdata.toC(&xc.platformdata); err != nil {
670 xc.poolid = C.uint32_t(x.Poolid)
672 xc.pool_name = C.CString(x.PoolName)}
673 if err := x.RunHotplugScripts.toC(&xc.run_hotplug_scripts); err != nil {
676 if err := x.DriverDomain.toC(&xc.driver_domain); err != nil {
679 xc.passthrough = C.libxl_passthrough(x.Passthrough)
680 if err := x.XendSuspendEvtchnCompat.toC(&xc.xend_suspend_evtchn_compat); err != nil {
691 xc C.libxl_domain_restore_params)
693 C.libxl_domain_restore_params_init(&xc)
694 defer C.libxl_domain_restore_params_dispose(&xc)
696 if err := x.fromC(&xc); err != nil {
701 func (x *DomainRestoreParams) fromC(xc *C.libxl_domain_restore_params) error {
702 x.CheckpointedStream = int(xc.checkpointed_stream)
703 x.StreamVersion = uint32(xc.stream_version)
704 x.ColoProxyScript = C.GoString(xc.colo_proxy_script)
705 if err := x.UserspaceColoProxy.fromC(&xc.userspace_colo_proxy);err != nil {
711 func (x *DomainRestoreParams) toC(xc *C.libxl_domain_restore_params) (err error){defer func(){
713 C.libxl_domain_restore_params_dispose(xc)}
716 xc.checkpointed_stream = C.int(x.CheckpointedStream)
717 xc.stream_version = C.uint32_t(x.StreamVersion)
719 xc.colo_proxy_script = C.CString(x.ColoProxyScript)}
720 if err := x.UserspaceColoProxy.toC(&xc.userspace_colo_proxy); err != nil {
731 xc C.libxl_sched_params)
733 C.libxl_sched_params_init(&xc)
734 defer C.libxl_sched_params_dispose(&xc)
736 if err := x.fromC(&xc); err != nil {
741 func (x *SchedParams) fromC(xc *C.libxl_sched_params) error {
742 x.Vcpuid = int(xc.vcpuid)
743 x.Weight = int(xc.weight)
744 x.Cap = int(xc.cap)
745 x.Period = int(xc.period)
746 x.Extratime = int(xc.extratime)
747 x.Budget = int(xc.budget)
751 func (x *SchedParams) toC(xc *C.libxl_sched_params) (err error){defer func(){
753 C.libxl_sched_params_dispose(xc)}
756 xc.vcpuid = C.int(x.Vcpuid)
757 xc.weight = C.int(x.Weight)
758 xc.cap = C.int(x.Cap)
759 xc.period = C.int(x.Period)
760 xc.extratime = C.int(x.Extratime)
761 xc.budget = C.int(x.Budget)
770 xc C.libxl_vcpu_sched_params)
772 C.libxl_vcpu_sched_params_init(&xc)
773 defer C.libxl_vcpu_sched_params_dispose(&xc)
775 if err := x.fromC(&xc); err != nil {
780 func (x *VcpuSchedParams) fromC(xc *C.libxl_vcpu_sched_params) error {
781 x.Sched = Scheduler(xc.sched)
783 if n := int(xc.num_vcpus); n > 0 {
784 cVcpus := (*[1<<28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:n:n]
794 func (x *VcpuSchedParams) toC(xc *C.libxl_vcpu_sched_params) (err error){defer func(){
796 C.libxl_vcpu_sched_params_dispose(xc)}
799 xc.sched = C.libxl_scheduler(x.Sched)
801 xc.vcpus = (*C.libxl_sched_params)(C.malloc(C.ulong(numVcpus)*C.sizeof_libxl_sched_params))
802 xc.num_vcpus = C.int(numVcpus)
803 cVcpus := (*[1<<28]C.libxl_sched_params)(unsafe.Pointer(xc.vcpus))[:numVcpus:numVcpus]
818 xc C.libxl_domain_sched_params)
820 C.libxl_domain_sched_params_init(&xc)
821 defer C.libxl_domain_sched_params_dispose(&xc)
823 if err := x.fromC(&xc); err != nil {
828 func (x *DomainSchedParams) fromC(xc *C.libxl_domain_sched_params) error {
829 x.Sched = Scheduler(xc.sched)
830 x.Weight = int(xc.weight)
831 x.Cap = int(xc.cap)
832 x.Period = int(xc.period)
833 x.Budget = int(xc.budget)
834 x.Extratime = int(xc.extratime)
835 x.Slice = int(xc.slice)
836 x.Latency = int(xc.latency)
840 func (x *DomainSchedParams) toC(xc *C.libxl_domain_sched_params) (err error){defer func(){
842 C.libxl_domain_sched_params_dispose(xc)}
845 xc.sched = C.libxl_scheduler(x.Sched)
846 xc.weight = C.int(x.Weight)
847 xc.cap = C.int(x.Cap)
848 xc.period = C.int(x.Period)
849 xc.budget = C.int(x.Budget)
850 xc.extratime = C.int(x.Extratime)
851 xc.slice = C.int(x.Slice)
852 xc.latency = C.int(x.Latency)
861 xc C.libxl_vnode_info)
863 C.libxl_vnode_info_init(&xc)
864 defer C.libxl_vnode_info_dispose(&xc)
866 if err := x.fromC(&xc); err != nil {
871 func (x *VnodeInfo) fromC(xc *C.libxl_vnode_info) error {
872 x.Memkb = uint64(xc.memkb)
874 if n := int(xc.num_distances); n > 0 {
875 cDistances := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.distances))[:n:n]
881 x.Pnode = uint32(xc.pnode)
882 if err := x.Vcpus.fromC(&xc.vcpus);err != nil {
888 func (x *VnodeInfo) toC(xc *C.libxl_vnode_info) (err error){defer func(){
890 C.libxl_vnode_info_dispose(xc)}
893 xc.memkb = C.uint64_t(x.Memkb)
895 xc.distances = (*C.uint32_t)(C.malloc(C.size_t(numDistances*numDistances)))
896 xc.num_distances = C.int(numDistances)
897 cDistances := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.distances))[:numDistances:numDistances]
902 xc.pnode = C.uint32_t(x.Pnode)
903 if err := x.Vcpus.toC(&xc.vcpus); err != nil {
914 xc C.libxl_rdm_reserve)
916 C.libxl_rdm_reserve_init(&xc)
917 defer C.libxl_rdm_reserve_dispose(&xc)
919 if err := x.fromC(&xc); err != nil {
924 func (x *RdmReserve) fromC(xc *C.libxl_rdm_reserve) error {
925 x.Strategy = RdmReserveStrategy(xc.strategy)
926 x.Policy = RdmReservePolicy(xc.policy)
930 func (x *RdmReserve) toC(xc *C.libxl_rdm_reserve) (err error){defer func(){
932 C.libxl_rdm_reserve_dispose(xc)}
935 xc.strategy = C.libxl_rdm_reserve_strategy(x.Strategy)
936 xc.policy = C.libxl_rdm_reserve_policy(x.Policy)
945 xc C.libxl_domain_build_info)
947 C.libxl_domain_build_info_init(&xc)
948 C.libxl_domain_build_info_init_type(&xc, C.libxl_domain_type(dtype))
949 defer C.libxl_domain_build_info_dispose(&xc)
951 if err := x.fromC(&xc); err != nil {
956 func (x *DomainBuildInfo) fromC(xc *C.libxl_domain_build_info) error {
957 x.MaxVcpus = int(xc.max_vcpus)
958 if err := x.AvailVcpus.fromC(&xc.avail_vcpus);err != nil {
961 if err := x.Cpumap.fromC(&xc.cpumap);err != nil {
964 if err := x.Nodemap.fromC(&xc.nodemap);err != nil {
968 if n := int(xc.num_vcpu_hard_affinity); n > 0 {
969 cVcpuHardAffinity := (*[1<<28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_hard_affinity))[:n:n]
977 if n := int(xc.num_vcpu_soft_affinity); n > 0 {
978 cVcpuSoftAffinity := (*[1<<28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_soft_affinity))[:n:n]
985 if err := x.NumaPlacement.fromC(&xc.numa_placement);err != nil {
988 x.TscMode = TscMode(xc.tsc_mode)
989 x.MaxMemkb = uint64(xc.max_memkb)
990 x.TargetMemkb = uint64(xc.target_memkb)
991 x.VideoMemkb = uint64(xc.video_memkb)
992 x.ShadowMemkb = uint64(xc.shadow_memkb)
993 x.IommuMemkb = uint64(xc.iommu_memkb)
994 x.RtcTimeoffset = uint32(xc.rtc_timeoffset)
995 x.ExecSsidref = uint32(xc.exec_ssidref)
996 x.ExecSsidLabel = C.GoString(xc.exec_ssid_label)
997 if err := x.Localtime.fromC(&xc.localtime);err != nil {
1000 if err := x.DisableMigrate.fromC(&xc.disable_migrate);err != nil {
1003 if err := x.Cpuid.fromC(&xc.cpuid);err != nil {
1006 x.BlkdevStart = C.GoString(xc.blkdev_start)
1008 if n := int(xc.num_vnuma_nodes); n > 0 {
1009 cVnumaNodes := (*[1<<28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_nodes))[:n:n]
1016 x.MaxGrantFrames = uint32(xc.max_grant_frames)
1017 x.MaxMaptrackFrames = uint32(xc.max_maptrack_frames)
1018 x.DeviceModelVersion = DeviceModelVersion(xc.device_model_version)
1019 if err := x.DeviceModelStubdomain.fromC(&xc.device_model_stubdomain);err != nil {
1022 x.StubdomainMemkb = uint64(xc.stubdomain_memkb)
1023 x.StubdomainKernel = C.GoString(xc.stubdomain_kernel)
1024 x.StubdomainRamdisk = C.GoString(xc.stubdomain_ramdisk)
1025 x.DeviceModel = C.GoString(xc.device_model)
1026 x.DeviceModelSsidref = uint32(xc.device_model_ssidref)
1027 x.DeviceModelSsidLabel = C.GoString(xc.device_model_ssid_label)
1028 x.DeviceModelUser = C.GoString(xc.device_model_user)
1029 if err := x.Extra.fromC(&xc.extra);err != nil {
1032 if err := x.ExtraPv.fromC(&xc.extra_pv);err != nil {
1035 if err := x.ExtraHvm.fromC(&xc.extra_hvm);err != nil {
1038 if err := x.SchedParams.fromC(&xc.sched_params);err != nil {
1042 if n := int(xc.num_ioports); n > 0 {
1043 cIoports := (*[1<<28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports))[:n:n]
1051 if n := int(xc.num_irqs); n > 0 {
1052 cIrqs := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:n:n]
1059 if n := int(xc.num_iomem); n > 0 {
1060 cIomem := (*[1<<28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:n:n]
1067 if err := x.ClaimMode.fromC(&xc.claim_mode);err != nil {
1070 x.EventChannels = uint32(xc.event_channels)
1071 x.Kernel = C.GoString(xc.kernel)
1072 x.Cmdline = C.GoString(xc.cmdline)
1073 x.Ramdisk = C.GoString(xc.ramdisk)
1074 x.DeviceTree = C.GoString(xc.device_tree)
1075 if err := x.Acpi.fromC(&xc.acpi);err != nil {
1078 x.Bootloader = C.GoString(xc.bootloader)
1079 if err := x.BootloaderArgs.fromC(&xc.bootloader_args);err != nil {
1082 x.TimerMode = TimerMode(xc.timer_mode)
1083 if err := x.NestedHvm.fromC(&xc.nested_hvm);err != nil {
1086 if err := x.Apic.fromC(&xc.apic);err != nil {
1089 if err := x.DmRestrict.fromC(&xc.dm_restrict);err != nil {
1092 x.Tee = TeeType(xc.tee)
1093 x.Type = DomainType(xc._type)
1097 if err := typeHvm.fromC(xc);err != nil {
1105 if err := typePv.fromC(xc);err != nil {
1111 if err := typePvh.fromC(xc);err != nil {
1117 x.ArchArm.GicVersion = GicVersion(xc.arch_arm.gic_version)
1118 x.ArchArm.Vuart = VuartType(xc.arch_arm.vuart)
1119 x.Altp2M = Altp2MMode(xc.altp2m)
1123 func (x *DomainBuildInfoTypeUnionHvm) fromC(xc *C.libxl_domain_build_info) error {
1124 if DomainType(xc._type) != DomainTypeHvm {
1128 tmp := (*C.libxl_domain_build_info_type_union_hvm)(unsafe.Pointer(&xc.u[0]))
1232 func (x *DomainBuildInfoTypeUnionPv) fromC(xc *C.libxl_domain_build_info) error {
1233 if DomainType(xc._type) != DomainTypePv {
1237 tmp := (*C.libxl_domain_build_info_type_union_pv)(unsafe.Pointer(&xc.u[0]))
1253 func (x *DomainBuildInfoTypeUnionPvh) fromC(xc *C.libxl_domain_build_info) error {
1254 if DomainType(xc._type) != DomainTypePvh {
1258 tmp := (*C.libxl_domain_build_info_type_union_pvh)(unsafe.Pointer(&xc.u[0]))
1268 func (x *DomainBuildInfo) toC(xc *C.libxl_domain_build_info) (err error){defer func(){
1270 C.libxl_domain_build_info_dispose(xc)}
1273 xc.max_vcpus = C.int(x.MaxVcpus)
1274 if err := x.AvailVcpus.toC(&xc.avail_vcpus); err != nil {
1277 if err := x.Cpumap.toC(&xc.cpumap); err != nil {
1280 if err := x.Nodemap.toC(&xc.nodemap); err != nil {
1284 xc.vcpu_hard_affinity = (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuHardAffinity)*C.sizeof_libxl_bitm…
1285 xc.num_vcpu_hard_affinity = C.int(numVcpuHardAffinity)
1286 cVcpuHardAffinity := (*[1<<28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_hard_affinity))[:numVcpuHardAf…
1294 xc.vcpu_soft_affinity = (*C.libxl_bitmap)(C.malloc(C.ulong(numVcpuSoftAffinity)*C.sizeof_libxl_bitm…
1295 xc.num_vcpu_soft_affinity = C.int(numVcpuSoftAffinity)
1296 cVcpuSoftAffinity := (*[1<<28]C.libxl_bitmap)(unsafe.Pointer(xc.vcpu_soft_affinity))[:numVcpuSoftAf…
1303 if err := x.NumaPlacement.toC(&xc.numa_placement); err != nil {
1306 xc.tsc_mode = C.libxl_tsc_mode(x.TscMode)
1307 xc.max_memkb = C.uint64_t(x.MaxMemkb)
1308 xc.target_memkb = C.uint64_t(x.TargetMemkb)
1309 xc.video_memkb = C.uint64_t(x.VideoMemkb)
1310 xc.shadow_memkb = C.uint64_t(x.ShadowMemkb)
1311 xc.iommu_memkb = C.uint64_t(x.IommuMemkb)
1312 xc.rtc_timeoffset = C.uint32_t(x.RtcTimeoffset)
1313 xc.exec_ssidref = C.uint32_t(x.ExecSsidref)
1315 xc.exec_ssid_label = C.CString(x.ExecSsidLabel)}
1316 if err := x.Localtime.toC(&xc.localtime); err != nil {
1319 if err := x.DisableMigrate.toC(&xc.disable_migrate); err != nil {
1322 if err := x.Cpuid.toC(&xc.cpuid); err != nil {
1326 xc.blkdev_start = C.CString(x.BlkdevStart)}
1328 xc.vnuma_nodes = (*C.libxl_vnode_info)(C.malloc(C.ulong(numVnumaNodes)*C.sizeof_libxl_vnode_info))
1329 xc.num_vnuma_nodes = C.int(numVnumaNodes)
1330 cVnumaNodes := (*[1<<28]C.libxl_vnode_info)(unsafe.Pointer(xc.vnuma_nodes))[:numVnumaNodes:numVnuma…
1337 xc.max_grant_frames = C.uint32_t(x.MaxGrantFrames)
1338 xc.max_maptrack_frames = C.uint32_t(x.MaxMaptrackFrames)
1339 xc.device_model_version = C.libxl_device_model_version(x.DeviceModelVersion)
1340 if err := x.DeviceModelStubdomain.toC(&xc.device_model_stubdomain); err != nil {
1343 xc.stubdomain_memkb = C.uint64_t(x.StubdomainMemkb)
1345 xc.stubdomain_kernel = C.CString(x.StubdomainKernel)}
1347 xc.stubdomain_ramdisk = C.CString(x.StubdomainRamdisk)}
1349 xc.device_model = C.CString(x.DeviceModel)}
1350 xc.device_model_ssidref = C.uint32_t(x.DeviceModelSsidref)
1352 xc.device_model_ssid_label = C.CString(x.DeviceModelSsidLabel)}
1354 xc.device_model_user = C.CString(x.DeviceModelUser)}
1355 if err := x.Extra.toC(&xc.extra); err != nil {
1358 if err := x.ExtraPv.toC(&xc.extra_pv); err != nil {
1361 if err := x.ExtraHvm.toC(&xc.extra_hvm); err != nil {
1364 if err := x.SchedParams.toC(&xc.sched_params); err != nil {
1368 xc.ioports = (*C.libxl_ioport_range)(C.malloc(C.ulong(numIoports)*C.sizeof_libxl_ioport_range))
1369 xc.num_ioports = C.int(numIoports)
1370 cIoports := (*[1<<28]C.libxl_ioport_range)(unsafe.Pointer(xc.ioports))[:numIoports:numIoports]
1378 xc.irqs = (*C.uint32_t)(C.malloc(C.size_t(numIrqs*numIrqs)))
1379 xc.num_irqs = C.int(numIrqs)
1380 cIrqs := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.irqs))[:numIrqs:numIrqs]
1386 xc.iomem = (*C.libxl_iomem_range)(C.malloc(C.ulong(numIomem)*C.sizeof_libxl_iomem_range))
1387 xc.num_iomem = C.int(numIomem)
1388 cIomem := (*[1<<28]C.libxl_iomem_range)(unsafe.Pointer(xc.iomem))[:numIomem:numIomem]
1395 if err := x.ClaimMode.toC(&xc.claim_mode); err != nil {
1398 xc.event_channels = C.uint32_t(x.EventChannels)
1400 xc.kernel = C.CString(x.Kernel)}
1402 xc.cmdline = C.CString(x.Cmdline)}
1404 xc.ramdisk = C.CString(x.Ramdisk)}
1406 xc.device_tree = C.CString(x.DeviceTree)}
1407 if err := x.Acpi.toC(&xc.acpi); err != nil {
1411 xc.bootloader = C.CString(x.Bootloader)}
1412 if err := x.BootloaderArgs.toC(&xc.bootloader_args); err != nil {
1415 xc.timer_mode = C.libxl_timer_mode(x.TimerMode)
1416 if err := x.NestedHvm.toC(&xc.nested_hvm); err != nil {
1419 if err := x.Apic.toC(&xc.apic); err != nil {
1422 if err := x.DmRestrict.toC(&xc.dm_restrict); err != nil {
1425 xc.tee = C.libxl_tee_type(x.Tee)
1426 xc._type = C.libxl_domain_type(x.Type)
1545 copy(xc.u[:],hvmBytes)
1570 copy(xc.u[:],pvBytes)
1587 copy(xc.u[:],pvhBytes)
1592 xc.arch_arm.gic_version = C.libxl_gic_version(x.ArchArm.GicVersion)
1593 xc.arch_arm.vuart = C.libxl_vuart_type(x.ArchArm.Vuart)
1594 xc.altp2m = C.libxl_altp2m_mode(x.Altp2M)
1603 xc C.libxl_device_vfb)
1605 C.libxl_device_vfb_init(&xc)
1606 defer C.libxl_device_vfb_dispose(&xc)
1608 if err := x.fromC(&xc); err != nil {
1613 func (x *DeviceVfb) fromC(xc *C.libxl_device_vfb) error {
1614 x.BackendDomid = Domid(xc.backend_domid)
1615 x.BackendDomname = C.GoString(xc.backend_domname)
1616 x.Devid = Devid(xc.devid)
1617 if err := x.Vnc.fromC(&xc.vnc);err != nil {
1620 if err := x.Sdl.fromC(&xc.sdl);err != nil {
1623 x.Keymap = C.GoString(xc.keymap)
1627 func (x *DeviceVfb) toC(xc *C.libxl_device_vfb) (err error){defer func(){
1629 C.libxl_device_vfb_dispose(xc)}
1632 xc.backend_domid = C.libxl_domid(x.BackendDomid)
1634 xc.backend_domname = C.CString(x.BackendDomname)}
1635 xc.devid = C.libxl_devid(x.Devid)
1636 if err := x.Vnc.toC(&xc.vnc); err != nil {
1639 if err := x.Sdl.toC(&xc.sdl); err != nil {
1643 xc.keymap = C.CString(x.Keymap)}
1652 xc C.libxl_device_vkb)
1654 C.libxl_device_vkb_init(&xc)
1655 defer C.libxl_device_vkb_dispose(&xc)
1657 if err := x.fromC(&xc); err != nil {
1662 func (x *DeviceVkb) fromC(xc *C.libxl_device_vkb) error {
1663 x.BackendDomid = Domid(xc.backend_domid)
1664 x.BackendDomname = C.GoString(xc.backend_domname)
1665 x.Devid = Devid(xc.devid)
1666 x.BackendType = VkbBackend(xc.backend_type)
1667 x.UniqueId = C.GoString(xc.unique_id)
1668 x.FeatureDisableKeyboard = bool(xc.feature_disable_keyboard)
1669 x.FeatureDisablePointer = bool(xc.feature_disable_pointer)
1670 x.FeatureAbsPointer = bool(xc.feature_abs_pointer)
1671 x.FeatureRawPointer = bool(xc.feature_raw_pointer)
1672 x.FeatureMultiTouch = bool(xc.feature_multi_touch)
1673 x.Width = uint32(xc.width)
1674 x.Height = uint32(xc.height)
1675 x.MultiTouchWidth = uint32(xc.multi_touch_width)
1676 x.MultiTouchHeight = uint32(xc.multi_touch_height)
1677 x.MultiTouchNumContacts = uint32(xc.multi_touch_num_contacts)
1681 func (x *DeviceVkb) toC(xc *C.libxl_device_vkb) (err error){defer func(){
1683 C.libxl_device_vkb_dispose(xc)}
1686 xc.backend_domid = C.libxl_domid(x.BackendDomid)
1688 xc.backend_domname = C.CString(x.BackendDomname)}
1689 xc.devid = C.libxl_devid(x.Devid)
1690 xc.backend_type = C.libxl_vkb_backend(x.BackendType)
1692 xc.unique_id = C.CString(x.UniqueId)}
1693 xc.feature_disable_keyboard = C.bool(x.FeatureDisableKeyboard)
1694 xc.feature_disable_pointer = C.bool(x.FeatureDisablePointer)
1695 xc.feature_abs_pointer = C.bool(x.FeatureAbsPointer)
1696 xc.feature_raw_pointer = C.bool(x.FeatureRawPointer)
1697 xc.feature_multi_touch = C.bool(x.FeatureMultiTouch)
1698 xc.width = C.uint32_t(x.Width)
1699 xc.height = C.uint32_t(x.Height)
1700 xc.multi_touch_width = C.uint32_t(x.MultiTouchWidth)
1701 xc.multi_touch_height = C.uint32_t(x.MultiTouchHeight)
1702 xc.multi_touch_num_contacts = C.uint32_t(x.MultiTouchNumContacts)
1711 xc C.libxl_device_disk)
1713 C.libxl_device_disk_init(&xc)
1714 defer C.libxl_device_disk_dispose(&xc)
1716 if err := x.fromC(&xc); err != nil {
1721 func (x *DeviceDisk) fromC(xc *C.libxl_device_disk) error {
1722 x.BackendDomid = Domid(xc.backend_domid)
1723 x.BackendDomname = C.GoString(xc.backend_domname)
1724 x.PdevPath = C.GoString(xc.pdev_path)
1725 x.Vdev = C.GoString(xc.vdev)
1726 x.Backend = DiskBackend(xc.backend)
1727 x.Format = DiskFormat(xc.format)
1728 x.Script = C.GoString(xc.script)
1729 x.Removable = int(xc.removable)
1730 x.Readwrite = int(xc.readwrite)
1731 x.IsCdrom = int(xc.is_cdrom)
1732 x.DirectIoSafe = bool(xc.direct_io_safe)
1733 if err := x.DiscardEnable.fromC(&xc.discard_enable);err != nil {
1736 if err := x.ColoEnable.fromC(&xc.colo_enable);err != nil {
1739 if err := x.ColoRestoreEnable.fromC(&xc.colo_restore_enable);err != nil {
1742 x.ColoHost = C.GoString(xc.colo_host)
1743 x.ColoPort = int(xc.colo_port)
1744 x.ColoExport = C.GoString(xc.colo_export)
1745 x.ActiveDisk = C.GoString(xc.active_disk)
1746 x.HiddenDisk = C.GoString(xc.hidden_disk)
1750 func (x *DeviceDisk) toC(xc *C.libxl_device_disk) (err error){defer func(){
1752 C.libxl_device_disk_dispose(xc)}
1755 xc.backend_domid = C.libxl_domid(x.BackendDomid)
1757 xc.backend_domname = C.CString(x.BackendDomname)}
1759 xc.pdev_path = C.CString(x.PdevPath)}
1761 xc.vdev = C.CString(x.Vdev)}
1762 xc.backend = C.libxl_disk_backend(x.Backend)
1763 xc.format = C.libxl_disk_format(x.Format)
1765 xc.script = C.CString(x.Script)}
1766 xc.removable = C.int(x.Removable)
1767 xc.readwrite = C.int(x.Readwrite)
1768 xc.is_cdrom = C.int(x.IsCdrom)
1769 xc.direct_io_safe = C.bool(x.DirectIoSafe)
1770 if err := x.DiscardEnable.toC(&xc.discard_enable); err != nil {
1773 if err := x.ColoEnable.toC(&xc.colo_enable); err != nil {
1776 if err := x.ColoRestoreEnable.toC(&xc.colo_restore_enable); err != nil {
1780 xc.colo_host = C.CString(x.ColoHost)}
1781 xc.colo_port = C.int(x.ColoPort)
1783 xc.colo_export = C.CString(x.ColoExport)}
1785 xc.active_disk = C.CString(x.ActiveDisk)}
1787 xc.hidden_disk = C.CString(x.HiddenDisk)}
1796 xc C.libxl_device_nic)
1798 C.libxl_device_nic_init(&xc)
1799 defer C.libxl_device_nic_dispose(&xc)
1801 if err := x.fromC(&xc); err != nil {
1806 func (x *DeviceNic) fromC(xc *C.libxl_device_nic) error {
1807 x.BackendDomid = Domid(xc.backend_domid)
1808 x.BackendDomname = C.GoString(xc.backend_domname)
1809 x.Devid = Devid(xc.devid)
1810 x.Mtu = int(xc.mtu)
1811 x.Model = C.GoString(xc.model)
1812 if err := x.Mac.fromC(&xc.mac);err != nil {
1815 x.Ip = C.GoString(xc.ip)
1816 x.Bridge = C.GoString(xc.bridge)
1817 x.Ifname = C.GoString(xc.ifname)
1818 x.Script = C.GoString(xc.script)
1819 x.Nictype = NicType(xc.nictype)
1820 x.RateBytesPerInterval = uint64(xc.rate_bytes_per_interval)
1821 x.RateIntervalUsecs = uint32(xc.rate_interval_usecs)
1822 x.Gatewaydev = C.GoString(xc.gatewaydev)
1823 x.ColoftForwarddev = C.GoString(xc.coloft_forwarddev)
1824 x.ColoSockMirrorId = C.GoString(xc.colo_sock_mirror_id)
1825 x.ColoSockMirrorIp = C.GoString(xc.colo_sock_mirror_ip)
1826 x.ColoSockMirrorPort = C.GoString(xc.colo_sock_mirror_port)
1827 x.ColoSockComparePriInId = C.GoString(xc.colo_sock_compare_pri_in_id)
1828 x.ColoSockComparePriInIp = C.GoString(xc.colo_sock_compare_pri_in_ip)
1829 x.ColoSockComparePriInPort = C.GoString(xc.colo_sock_compare_pri_in_port)
1830 x.ColoSockCompareSecInId = C.GoString(xc.colo_sock_compare_sec_in_id)
1831 x.ColoSockCompareSecInIp = C.GoString(xc.colo_sock_compare_sec_in_ip)
1832 x.ColoSockCompareSecInPort = C.GoString(xc.colo_sock_compare_sec_in_port)
1833 x.ColoSockCompareNotifyId = C.GoString(xc.colo_sock_compare_notify_id)
1834 x.ColoSockCompareNotifyIp = C.GoString(xc.colo_sock_compare_notify_ip)
1835 x.ColoSockCompareNotifyPort = C.GoString(xc.colo_sock_compare_notify_port)
1836 x.ColoSockRedirector0Id = C.GoString(xc.colo_sock_redirector0_id)
1837 x.ColoSockRedirector0Ip = C.GoString(xc.colo_sock_redirector0_ip)
1838 x.ColoSockRedirector0Port = C.GoString(xc.colo_sock_redirector0_port)
1839 x.ColoSockRedirector1Id = C.GoString(xc.colo_sock_redirector1_id)
1840 x.ColoSockRedirector1Ip = C.GoString(xc.colo_sock_redirector1_ip)
1841 x.ColoSockRedirector1Port = C.GoString(xc.colo_sock_redirector1_port)
1842 x.ColoSockRedirector2Id = C.GoString(xc.colo_sock_redirector2_id)
1843 x.ColoSockRedirector2Ip = C.GoString(xc.colo_sock_redirector2_ip)
1844 x.ColoSockRedirector2Port = C.GoString(xc.colo_sock_redirector2_port)
1845 x.ColoFilterMirrorQueue = C.GoString(xc.colo_filter_mirror_queue)
1846 x.ColoFilterMirrorOutdev = C.GoString(xc.colo_filter_mirror_outdev)
1847 x.ColoFilterRedirector0Queue = C.GoString(xc.colo_filter_redirector0_queue)
1848 x.ColoFilterRedirector0Indev = C.GoString(xc.colo_filter_redirector0_indev)
1849 x.ColoFilterRedirector0Outdev = C.GoString(xc.colo_filter_redirector0_outdev)
1850 x.ColoFilterRedirector1Queue = C.GoString(xc.colo_filter_redirector1_queue)
1851 x.ColoFilterRedirector1Indev = C.GoString(xc.colo_filter_redirector1_indev)
1852 x.ColoFilterRedirector1Outdev = C.GoString(xc.colo_filter_redirector1_outdev)
1853 x.ColoComparePriIn = C.GoString(xc.colo_compare_pri_in)
1854 x.ColoCompareSecIn = C.GoString(xc.colo_compare_sec_in)
1855 x.ColoCompareOut = C.GoString(xc.colo_compare_out)
1856 x.ColoCompareNotifyDev = C.GoString(xc.colo_compare_notify_dev)
1857 x.ColoSockSecRedirector0Id = C.GoString(xc.colo_sock_sec_redirector0_id)
1858 x.ColoSockSecRedirector0Ip = C.GoString(xc.colo_sock_sec_redirector0_ip)
1859 x.ColoSockSecRedirector0Port = C.GoString(xc.colo_sock_sec_redirector0_port)
1860 x.ColoSockSecRedirector1Id = C.GoString(xc.colo_sock_sec_redirector1_id)
1861 x.ColoSockSecRedirector1Ip = C.GoString(xc.colo_sock_sec_redirector1_ip)
1862 x.ColoSockSecRedirector1Port = C.GoString(xc.colo_sock_sec_redirector1_port)
1863 x.ColoFilterSecRedirector0Queue = C.GoString(xc.colo_filter_sec_redirector0_queue)
1864 x.ColoFilterSecRedirector0Indev = C.GoString(xc.colo_filter_sec_redirector0_indev)
1865 x.ColoFilterSecRedirector0Outdev = C.GoString(xc.colo_filter_sec_redirector0_outdev)
1866 x.ColoFilterSecRedirector1Queue = C.GoString(xc.colo_filter_sec_redirector1_queue)
1867 x.ColoFilterSecRedirector1Indev = C.GoString(xc.colo_filter_sec_redirector1_indev)
1868 x.ColoFilterSecRedirector1Outdev = C.GoString(xc.colo_filter_sec_redirector1_outdev)
1869 x.ColoFilterSecRewriter0Queue = C.GoString(xc.colo_filter_sec_rewriter0_queue)
1870 x.ColoCheckpointHost = C.GoString(xc.colo_checkpoint_host)
1871 x.ColoCheckpointPort = C.GoString(xc.colo_checkpoint_port)
1875 func (x *DeviceNic) toC(xc *C.libxl_device_nic) (err error){defer func(){
1877 C.libxl_device_nic_dispose(xc)}
1880 xc.backend_domid = C.libxl_domid(x.BackendDomid)
1882 xc.backend_domname = C.CString(x.BackendDomname)}
1883 xc.devid = C.libxl_devid(x.Devid)
1884 xc.mtu = C.int(x.Mtu)
1886 xc.model = C.CString(x.Model)}
1887 if err := x.Mac.toC(&xc.mac); err != nil {
1891 xc.ip = C.CString(x.Ip)}
1893 xc.bridge = C.CString(x.Bridge)}
1895 xc.ifname = C.CString(x.Ifname)}
1897 xc.script = C.CString(x.Script)}
1898 xc.nictype = C.libxl_nic_type(x.Nictype)
1899 xc.rate_bytes_per_interval = C.uint64_t(x.RateBytesPerInterval)
1900 xc.rate_interval_usecs = C.uint32_t(x.RateIntervalUsecs)
1902 xc.gatewaydev = C.CString(x.Gatewaydev)}
1904 xc.coloft_forwarddev = C.CString(x.ColoftForwarddev)}
1906 xc.colo_sock_mirror_id = C.CString(x.ColoSockMirrorId)}
1908 xc.colo_sock_mirror_ip = C.CString(x.ColoSockMirrorIp)}
1910 xc.colo_sock_mirror_port = C.CString(x.ColoSockMirrorPort)}
1912 xc.colo_sock_compare_pri_in_id = C.CString(x.ColoSockComparePriInId)}
1914 xc.colo_sock_compare_pri_in_ip = C.CString(x.ColoSockComparePriInIp)}
1916 xc.colo_sock_compare_pri_in_port = C.CString(x.ColoSockComparePriInPort)}
1918 xc.colo_sock_compare_sec_in_id = C.CString(x.ColoSockCompareSecInId)}
1920 xc.colo_sock_compare_sec_in_ip = C.CString(x.ColoSockCompareSecInIp)}
1922 xc.colo_sock_compare_sec_in_port = C.CString(x.ColoSockCompareSecInPort)}
1924 xc.colo_sock_compare_notify_id = C.CString(x.ColoSockCompareNotifyId)}
1926 xc.colo_sock_compare_notify_ip = C.CString(x.ColoSockCompareNotifyIp)}
1928 xc.colo_sock_compare_notify_port = C.CString(x.ColoSockCompareNotifyPort)}
1930 xc.colo_sock_redirector0_id = C.CString(x.ColoSockRedirector0Id)}
1932 xc.colo_sock_redirector0_ip = C.CString(x.ColoSockRedirector0Ip)}
1934 xc.colo_sock_redirector0_port = C.CString(x.ColoSockRedirector0Port)}
1936 xc.colo_sock_redirector1_id = C.CString(x.ColoSockRedirector1Id)}
1938 xc.colo_sock_redirector1_ip = C.CString(x.ColoSockRedirector1Ip)}
1940 xc.colo_sock_redirector1_port = C.CString(x.ColoSockRedirector1Port)}
1942 xc.colo_sock_redirector2_id = C.CString(x.ColoSockRedirector2Id)}
1944 xc.colo_sock_redirector2_ip = C.CString(x.ColoSockRedirector2Ip)}
1946 xc.colo_sock_redirector2_port = C.CString(x.ColoSockRedirector2Port)}
1948 xc.colo_filter_mirror_queue = C.CString(x.ColoFilterMirrorQueue)}
1950 xc.colo_filter_mirror_outdev = C.CString(x.ColoFilterMirrorOutdev)}
1952 xc.colo_filter_redirector0_queue = C.CString(x.ColoFilterRedirector0Queue)}
1954 xc.colo_filter_redirector0_indev = C.CString(x.ColoFilterRedirector0Indev)}
1956 xc.colo_filter_redirector0_outdev = C.CString(x.ColoFilterRedirector0Outdev)}
1958 xc.colo_filter_redirector1_queue = C.CString(x.ColoFilterRedirector1Queue)}
1960 xc.colo_filter_redirector1_indev = C.CString(x.ColoFilterRedirector1Indev)}
1962 xc.colo_filter_redirector1_outdev = C.CString(x.ColoFilterRedirector1Outdev)}
1964 xc.colo_compare_pri_in = C.CString(x.ColoComparePriIn)}
1966 xc.colo_compare_sec_in = C.CString(x.ColoCompareSecIn)}
1968 xc.colo_compare_out = C.CString(x.ColoCompareOut)}
1970 xc.colo_compare_notify_dev = C.CString(x.ColoCompareNotifyDev)}
1972 xc.colo_sock_sec_redirector0_id = C.CString(x.ColoSockSecRedirector0Id)}
1974 xc.colo_sock_sec_redirector0_ip = C.CString(x.ColoSockSecRedirector0Ip)}
1976 xc.colo_sock_sec_redirector0_port = C.CString(x.ColoSockSecRedirector0Port)}
1978 xc.colo_sock_sec_redirector1_id = C.CString(x.ColoSockSecRedirector1Id)}
1980 xc.colo_sock_sec_redirector1_ip = C.CString(x.ColoSockSecRedirector1Ip)}
1982 xc.colo_sock_sec_redirector1_port = C.CString(x.ColoSockSecRedirector1Port)}
1984 xc.colo_filter_sec_redirector0_queue = C.CString(x.ColoFilterSecRedirector0Queue)}
1986 xc.colo_filter_sec_redirector0_indev = C.CString(x.ColoFilterSecRedirector0Indev)}
1988 xc.colo_filter_sec_redirector0_outdev = C.CString(x.ColoFilterSecRedirector0Outdev)}
1990 xc.colo_filter_sec_redirector1_queue = C.CString(x.ColoFilterSecRedirector1Queue)}
1992 xc.colo_filter_sec_redirector1_indev = C.CString(x.ColoFilterSecRedirector1Indev)}
1994 xc.colo_filter_sec_redirector1_outdev = C.CString(x.ColoFilterSecRedirector1Outdev)}
1996 xc.colo_filter_sec_rewriter0_queue = C.CString(x.ColoFilterSecRewriter0Queue)}
1998 xc.colo_checkpoint_host = C.CString(x.ColoCheckpointHost)}
2000 xc.colo_checkpoint_port = C.CString(x.ColoCheckpointPort)}
2009 xc C.libxl_device_pci)
2011 C.libxl_device_pci_init(&xc)
2012 defer C.libxl_device_pci_dispose(&xc)
2014 if err := x.fromC(&xc); err != nil {
2019 func (x *DevicePci) fromC(xc *C.libxl_device_pci) error {
2020 x.Func = byte(xc._func)
2021 x.Dev = byte(xc.dev)
2022 x.Bus = byte(xc.bus)
2023 x.Domain = int(xc.domain)
2024 x.Vdevfn = uint32(xc.vdevfn)
2025 x.VfuncMask = uint32(xc.vfunc_mask)
2026 x.Msitranslate = bool(xc.msitranslate)
2027 x.PowerMgmt = bool(xc.power_mgmt)
2028 x.Permissive = bool(xc.permissive)
2029 x.Seize = bool(xc.seize)
2030 x.RdmPolicy = RdmReservePolicy(xc.rdm_policy)
2034 func (x *DevicePci) toC(xc *C.libxl_device_pci) (err error){defer func(){
2036 C.libxl_device_pci_dispose(xc)}
2039 xc._func = C.uint8_t(x.Func)
2040 xc.dev = C.uint8_t(x.Dev)
2041 xc.bus = C.uint8_t(x.Bus)
2042 xc.domain = C.int(x.Domain)
2043 xc.vdevfn = C.uint32_t(x.Vdevfn)
2044 xc.vfunc_mask = C.uint32_t(x.VfuncMask)
2045 xc.msitranslate = C.bool(x.Msitranslate)
2046 xc.power_mgmt = C.bool(x.PowerMgmt)
2047 xc.permissive = C.bool(x.Permissive)
2048 xc.seize = C.bool(x.Seize)
2049 xc.rdm_policy = C.libxl_rdm_reserve_policy(x.RdmPolicy)
2058 xc C.libxl_device_rdm)
2060 C.libxl_device_rdm_init(&xc)
2061 defer C.libxl_device_rdm_dispose(&xc)
2063 if err := x.fromC(&xc); err != nil {
2068 func (x *DeviceRdm) fromC(xc *C.libxl_device_rdm) error {
2069 x.Start = uint64(xc.start)
2070 x.Size = uint64(xc.size)
2071 x.Policy = RdmReservePolicy(xc.policy)
2075 func (x *DeviceRdm) toC(xc *C.libxl_device_rdm) (err error){defer func(){
2077 C.libxl_device_rdm_dispose(xc)}
2080 xc.start = C.uint64_t(x.Start)
2081 xc.size = C.uint64_t(x.Size)
2082 xc.policy = C.libxl_rdm_reserve_policy(x.Policy)
2091 xc C.libxl_device_usbctrl)
2093 C.libxl_device_usbctrl_init(&xc)
2094 defer C.libxl_device_usbctrl_dispose(&xc)
2096 if err := x.fromC(&xc); err != nil {
2101 func (x *DeviceUsbctrl) fromC(xc *C.libxl_device_usbctrl) error {
2102 x.Type = UsbctrlType(xc._type)
2103 x.Devid = Devid(xc.devid)
2104 x.Version = int(xc.version)
2105 x.Ports = int(xc.ports)
2106 x.BackendDomid = Domid(xc.backend_domid)
2107 x.BackendDomname = C.GoString(xc.backend_domname)
2111 func (x *DeviceUsbctrl) toC(xc *C.libxl_device_usbctrl) (err error){defer func(){
2113 C.libxl_device_usbctrl_dispose(xc)}
2116 xc._type = C.libxl_usbctrl_type(x.Type)
2117 xc.devid = C.libxl_devid(x.Devid)
2118 xc.version = C.int(x.Version)
2119 xc.ports = C.int(x.Ports)
2120 xc.backend_domid = C.libxl_domid(x.BackendDomid)
2122 xc.backend_domname = C.CString(x.BackendDomname)}
2131 xc C.libxl_device_usbdev)
2133 C.libxl_device_usbdev_init(&xc)
2134 C.libxl_device_usbdev_init_type(&xc, C.libxl_usbdev_type(utype))
2135 defer C.libxl_device_usbdev_dispose(&xc)
2137 if err := x.fromC(&xc); err != nil {
2142 func (x *DeviceUsbdev) fromC(xc *C.libxl_device_usbdev) error {
2143 x.Ctrl = Devid(xc.ctrl)
2144 x.Port = int(xc.port)
2145 x.Type = UsbdevType(xc._type)
2149 if err := typeHostdev.fromC(xc);err != nil {
2158 func (x *DeviceUsbdevTypeUnionHostdev) fromC(xc *C.libxl_device_usbdev) error {
2159 if UsbdevType(xc._type) != UsbdevTypeHostdev {
2163 tmp := (*C.libxl_device_usbdev_type_union_hostdev)(unsafe.Pointer(&xc.u[0]))
2169 func (x *DeviceUsbdev) toC(xc *C.libxl_device_usbdev) (err error){defer func(){
2171 C.libxl_device_usbdev_dispose(xc)}
2174 xc.ctrl = C.libxl_devid(x.Ctrl)
2175 xc.port = C.int(x.Port)
2176 xc._type = C.libxl_usbdev_type(x.Type)
2187 copy(xc.u[:],hostdevBytes)
2198 xc C.libxl_device_dtdev)
2200 C.libxl_device_dtdev_init(&xc)
2201 defer C.libxl_device_dtdev_dispose(&xc)
2203 if err := x.fromC(&xc); err != nil {
2208 func (x *DeviceDtdev) fromC(xc *C.libxl_device_dtdev) error {
2209 x.Path = C.GoString(xc.path)
2213 func (x *DeviceDtdev) toC(xc *C.libxl_device_dtdev) (err error){defer func(){
2215 C.libxl_device_dtdev_dispose(xc)}
2219 xc.path = C.CString(x.Path)}
2228 xc C.libxl_device_vtpm)
2230 C.libxl_device_vtpm_init(&xc)
2231 defer C.libxl_device_vtpm_dispose(&xc)
2233 if err := x.fromC(&xc); err != nil {
2238 func (x *DeviceVtpm) fromC(xc *C.libxl_device_vtpm) error {
2239 x.BackendDomid = Domid(xc.backend_domid)
2240 x.BackendDomname = C.GoString(xc.backend_domname)
2241 x.Devid = Devid(xc.devid)
2242 if err := x.Uuid.fromC(&xc.uuid);err != nil {
2248 func (x *DeviceVtpm) toC(xc *C.libxl_device_vtpm) (err error){defer func(){
2250 C.libxl_device_vtpm_dispose(xc)}
2253 xc.backend_domid = C.libxl_domid(x.BackendDomid)
2255 xc.backend_domname = C.CString(x.BackendDomname)}
2256 xc.devid = C.libxl_devid(x.Devid)
2257 if err := x.Uuid.toC(&xc.uuid); err != nil {
2268 xc C.libxl_device_p9)
2270 C.libxl_device_p9_init(&xc)
2271 defer C.libxl_device_p9_dispose(&xc)
2273 if err := x.fromC(&xc); err != nil {
2278 func (x *DeviceP9) fromC(xc *C.libxl_device_p9) error {
2279 x.BackendDomid = Domid(xc.backend_domid)
2280 x.BackendDomname = C.GoString(xc.backend_domname)
2281 x.Tag = C.GoString(xc.tag)
2282 x.Path = C.GoString(xc.path)
2283 x.SecurityModel = C.GoString(xc.security_model)
2284 x.Devid = Devid(xc.devid)
2288 func (x *DeviceP9) toC(xc *C.libxl_device_p9) (err error){defer func(){
2290 C.libxl_device_p9_dispose(xc)}
2293 xc.backend_domid = C.libxl_domid(x.BackendDomid)
2295 xc.backend_domname = C.CString(x.BackendDomname)}
2297 xc.tag = C.CString(x.Tag)}
2299 xc.path = C.CString(x.Path)}
2301 xc.security_model = C.CString(x.SecurityModel)}
2302 xc.devid = C.libxl_devid(x.Devid)
2311 xc C.libxl_device_pvcallsif)
2313 C.libxl_device_pvcallsif_init(&xc)
2314 defer C.libxl_device_pvcallsif_dispose(&xc)
2316 if err := x.fromC(&xc); err != nil {
2321 func (x *DevicePvcallsif) fromC(xc *C.libxl_device_pvcallsif) error {
2322 x.BackendDomid = Domid(xc.backend_domid)
2323 x.BackendDomname = C.GoString(xc.backend_domname)
2324 x.Devid = Devid(xc.devid)
2328 func (x *DevicePvcallsif) toC(xc *C.libxl_device_pvcallsif) (err error){defer func(){
2330 C.libxl_device_pvcallsif_dispose(xc)}
2333 xc.backend_domid = C.libxl_domid(x.BackendDomid)
2335 xc.backend_domname = C.CString(x.BackendDomname)}
2336 xc.devid = C.libxl_devid(x.Devid)
2345 xc C.libxl_device_channel)
2347 C.libxl_device_channel_init(&xc)
2348 C.libxl_device_channel_init_connection(&xc, C.libxl_channel_connection(connection))
2349 defer C.libxl_device_channel_dispose(&xc)
2351 if err := x.fromC(&xc); err != nil {
2356 func (x *DeviceChannel) fromC(xc *C.libxl_device_channel) error {
2357 x.BackendDomid = Domid(xc.backend_domid)
2358 x.BackendDomname = C.GoString(xc.backend_domname)
2359 x.Devid = Devid(xc.devid)
2360 x.Name = C.GoString(xc.name)
2361 x.Connection = ChannelConnection(xc.connection)
2367 if err := connectionSocket.fromC(xc);err != nil {
2378 func (x *DeviceChannelConnectionUnionSocket) fromC(xc *C.libxl_device_channel) error {
2379 if ChannelConnection(xc.connection) != ChannelConnectionSocket {
2383 tmp := (*C.libxl_device_channel_connection_union_socket)(unsafe.Pointer(&xc.u[0]))
2388 func (x *DeviceChannel) toC(xc *C.libxl_device_channel) (err error){defer func(){
2390 C.libxl_device_channel_dispose(xc)}
2393 xc.backend_domid = C.libxl_domid(x.BackendDomid)
2395 xc.backend_domname = C.CString(x.BackendDomname)}
2396 xc.devid = C.libxl_devid(x.Devid)
2398 xc.name = C.CString(x.Name)}
2399 xc.connection = C.libxl_channel_connection(x.Connection)
2414 copy(xc.u[:],socketBytes)
2425 xc C.libxl_connector_param)
2427 C.libxl_connector_param_init(&xc)
2428 defer C.libxl_connector_param_dispose(&xc)
2430 if err := x.fromC(&xc); err != nil {
2435 func (x *ConnectorParam) fromC(xc *C.libxl_connector_param) error {
2436 x.UniqueId = C.GoString(xc.unique_id)
2437 x.Width = uint32(xc.width)
2438 x.Height = uint32(xc.height)
2442 func (x *ConnectorParam) toC(xc *C.libxl_connector_param) (err error){defer func(){
2444 C.libxl_connector_param_dispose(xc)}
2448 xc.unique_id = C.CString(x.UniqueId)}
2449 xc.width = C.uint32_t(x.Width)
2450 xc.height = C.uint32_t(x.Height)
2459 xc C.libxl_device_vdispl)
2461 C.libxl_device_vdispl_init(&xc)
2462 defer C.libxl_device_vdispl_dispose(&xc)
2464 if err := x.fromC(&xc); err != nil {
2469 func (x *DeviceVdispl) fromC(xc *C.libxl_device_vdispl) error {
2470 x.BackendDomid = Domid(xc.backend_domid)
2471 x.BackendDomname = C.GoString(xc.backend_domname)
2472 x.Devid = Devid(xc.devid)
2473 x.BeAlloc = bool(xc.be_alloc)
2475 if n := int(xc.num_connectors); n > 0 {
2476 cConnectors := (*[1<<28]C.libxl_connector_param)(unsafe.Pointer(xc.connectors))[:n:n]
2486 func (x *DeviceVdispl) toC(xc *C.libxl_device_vdispl) (err error){defer func(){
2488 C.libxl_device_vdispl_dispose(xc)}
2491 xc.backend_domid = C.libxl_domid(x.BackendDomid)
2493 xc.backend_domname = C.CString(x.BackendDomname)}
2494 xc.devid = C.libxl_devid(x.Devid)
2495 xc.be_alloc = C.bool(x.BeAlloc)
2497 xc.connectors = (*C.libxl_connector_param)(C.malloc(C.ulong(numConnectors)*C.sizeof_libxl_connector…
2498 xc.num_connectors = C.int(numConnectors)
2499 cConnectors := (*[1<<28]C.libxl_connector_param)(unsafe.Pointer(xc.connectors))[:numConnectors:numC…
2514 xc C.libxl_vsnd_params)
2516 C.libxl_vsnd_params_init(&xc)
2517 defer C.libxl_vsnd_params_dispose(&xc)
2519 if err := x.fromC(&xc); err != nil {
2524 func (x *VsndParams) fromC(xc *C.libxl_vsnd_params) error {
2526 if n := int(xc.num_sample_rates); n > 0 {
2527 cSampleRates := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.sample_rates))[:n:n]
2534 if n := int(xc.num_sample_formats); n > 0 {
2535 cSampleFormats := (*[1<<28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc.sample_formats))[:n:n]
2541 x.ChannelsMin = uint32(xc.channels_min)
2542 x.ChannelsMax = uint32(xc.channels_max)
2543 x.BufferSize = uint32(xc.buffer_size)
2547 func (x *VsndParams) toC(xc *C.libxl_vsnd_params) (err error){defer func(){
2549 C.libxl_vsnd_params_dispose(xc)}
2553 xc.sample_rates = (*C.uint32_t)(C.malloc(C.size_t(numSampleRates*numSampleRates)))
2554 xc.num_sample_rates = C.int(numSampleRates)
2555 cSampleRates := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.sample_rates))[:numSampleRates:numSampleRate…
2561 xc.sample_formats = (*C.libxl_vsnd_pcm_format)(C.malloc(C.size_t(numSampleFormats*numSampleFormats)…
2562 xc.num_sample_formats = C.int(numSampleFormats)
2563 cSampleFormats := (*[1<<28]C.libxl_vsnd_pcm_format)(unsafe.Pointer(xc.sample_formats))[:numSampleFo…
2568 xc.channels_min = C.uint32_t(x.ChannelsMin)
2569 xc.channels_max = C.uint32_t(x.ChannelsMax)
2570 xc.buffer_size = C.uint32_t(x.BufferSize)
2579 xc C.libxl_vsnd_stream)
2581 C.libxl_vsnd_stream_init(&xc)
2582 defer C.libxl_vsnd_stream_dispose(&xc)
2584 if err := x.fromC(&xc); err != nil {
2589 func (x *VsndStream) fromC(xc *C.libxl_vsnd_stream) error {
2590 x.UniqueId = C.GoString(xc.unique_id)
2591 x.Type = VsndStreamType(xc._type)
2592 if err := x.Params.fromC(&xc.params);err != nil {
2598 func (x *VsndStream) toC(xc *C.libxl_vsnd_stream) (err error){defer func(){
2600 C.libxl_vsnd_stream_dispose(xc)}
2604 xc.unique_id = C.CString(x.UniqueId)}
2605 xc._type = C.libxl_vsnd_stream_type(x.Type)
2606 if err := x.Params.toC(&xc.params); err != nil {
2617 xc C.libxl_vsnd_pcm)
2619 C.libxl_vsnd_pcm_init(&xc)
2620 defer C.libxl_vsnd_pcm_dispose(&xc)
2622 if err := x.fromC(&xc); err != nil {
2627 func (x *VsndPcm) fromC(xc *C.libxl_vsnd_pcm) error {
2628 x.Name = C.GoString(xc.name)
2629 if err := x.Params.fromC(&xc.params);err != nil {
2633 if n := int(xc.num_vsnd_streams); n > 0 {
2634 cStreams := (*[1<<28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams))[:n:n]
2644 func (x *VsndPcm) toC(xc *C.libxl_vsnd_pcm) (err error){defer func(){
2646 C.libxl_vsnd_pcm_dispose(xc)}
2650 xc.name = C.CString(x.Name)}
2651 if err := x.Params.toC(&xc.params); err != nil {
2655 xc.streams = (*C.libxl_vsnd_stream)(C.malloc(C.ulong(numVsndStreams)*C.sizeof_libxl_vsnd_stream))
2656 xc.num_vsnd_streams = C.int(numVsndStreams)
2657 cStreams := (*[1<<28]C.libxl_vsnd_stream)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStream…
2672 xc C.libxl_device_vsnd)
2674 C.libxl_device_vsnd_init(&xc)
2675 defer C.libxl_device_vsnd_dispose(&xc)
2677 if err := x.fromC(&xc); err != nil {
2682 func (x *DeviceVsnd) fromC(xc *C.libxl_device_vsnd) error {
2683 x.BackendDomid = Domid(xc.backend_domid)
2684 x.BackendDomname = C.GoString(xc.backend_domname)
2685 x.Devid = Devid(xc.devid)
2686 x.ShortName = C.GoString(xc.short_name)
2687 x.LongName = C.GoString(xc.long_name)
2688 if err := x.Params.fromC(&xc.params);err != nil {
2692 if n := int(xc.num_vsnd_pcms); n > 0 {
2693 cPcms := (*[1<<28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:n:n]
2703 func (x *DeviceVsnd) toC(xc *C.libxl_device_vsnd) (err error){defer func(){
2705 C.libxl_device_vsnd_dispose(xc)}
2708 xc.backend_domid = C.libxl_domid(x.BackendDomid)
2710 xc.backend_domname = C.CString(x.BackendDomname)}
2711 xc.devid = C.libxl_devid(x.Devid)
2713 xc.short_name = C.CString(x.ShortName)}
2715 xc.long_name = C.CString(x.LongName)}
2716 if err := x.Params.toC(&xc.params); err != nil {
2720 xc.pcms = (*C.libxl_vsnd_pcm)(C.malloc(C.ulong(numVsndPcms)*C.sizeof_libxl_vsnd_pcm))
2721 xc.num_vsnd_pcms = C.int(numVsndPcms)
2722 cPcms := (*[1<<28]C.libxl_vsnd_pcm)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms]
2737 xc C.libxl_domain_config)
2739 C.libxl_domain_config_init(&xc)
2740 defer C.libxl_domain_config_dispose(&xc)
2742 if err := x.fromC(&xc); err != nil {
2747 func (x *DomainConfig) fromC(xc *C.libxl_domain_config) error {
2748 if err := x.CInfo.fromC(&xc.c_info);err != nil {
2751 if err := x.BInfo.fromC(&xc.b_info);err != nil {
2755 if n := int(xc.num_disks); n > 0 {
2756 cDisks := (*[1<<28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:n:n]
2764 if n := int(xc.num_nics); n > 0 {
2765 cNics := (*[1<<28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:n:n]
2773 if n := int(xc.num_pcidevs); n > 0 {
2774 cPcidevs := (*[1<<28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))[:n:n]
2782 if n := int(xc.num_rdms); n > 0 {
2783 cRdms := (*[1<<28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:n:n]
2791 if n := int(xc.num_dtdevs); n > 0 {
2792 cDtdevs := (*[1<<28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))[:n:n]
2800 if n := int(xc.num_vfbs); n > 0 {
2801 cVfbs := (*[1<<28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:n:n]
2809 if n := int(xc.num_vkbs); n > 0 {
2810 cVkbs := (*[1<<28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:n:n]
2818 if n := int(xc.num_vtpms); n > 0 {
2819 cVtpms := (*[1<<28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:n:n]
2827 if n := int(xc.num_p9s); n > 0 {
2828 cP9S := (*[1<<28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:n:n]
2836 if n := int(xc.num_pvcallsifs); n > 0 {
2837 cPvcallsifs := (*[1<<28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.pvcallsifs))[:n:n]
2845 if n := int(xc.num_vdispls); n > 0 {
2846 cVdispls := (*[1<<28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispls))[:n:n]
2854 if n := int(xc.num_vsnds); n > 0 {
2855 cVsnds := (*[1<<28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:n:n]
2863 if n := int(xc.num_channels); n > 0 {
2864 cChannels := (*[1<<28]C.libxl_device_channel)(unsafe.Pointer(xc.channels))[:n:n]
2872 if n := int(xc.num_usbctrls); n > 0 {
2873 cUsbctrls := (*[1<<28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbctrls))[:n:n]
2881 if n := int(xc.num_usbdevs); n > 0 {
2882 cUsbdevs := (*[1<<28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdevs))[:n:n]
2889 x.OnPoweroff = ActionOnShutdown(xc.on_poweroff)
2890 x.OnReboot = ActionOnShutdown(xc.on_reboot)
2891 x.OnWatchdog = ActionOnShutdown(xc.on_watchdog)
2892 x.OnCrash = ActionOnShutdown(xc.on_crash)
2893 x.OnSoftReset = ActionOnShutdown(xc.on_soft_reset)
2897 func (x *DomainConfig) toC(xc *C.libxl_domain_config) (err error){defer func(){
2899 C.libxl_domain_config_dispose(xc)}
2902 if err := x.CInfo.toC(&xc.c_info); err != nil {
2905 if err := x.BInfo.toC(&xc.b_info); err != nil {
2909 xc.disks = (*C.libxl_device_disk)(C.malloc(C.ulong(numDisks)*C.sizeof_libxl_device_disk))
2910 xc.num_disks = C.int(numDisks)
2911 cDisks := (*[1<<28]C.libxl_device_disk)(unsafe.Pointer(xc.disks))[:numDisks:numDisks]
2919 xc.nics = (*C.libxl_device_nic)(C.malloc(C.ulong(numNics)*C.sizeof_libxl_device_nic))
2920 xc.num_nics = C.int(numNics)
2921 cNics := (*[1<<28]C.libxl_device_nic)(unsafe.Pointer(xc.nics))[:numNics:numNics]
2929 xc.pcidevs = (*C.libxl_device_pci)(C.malloc(C.ulong(numPcidevs)*C.sizeof_libxl_device_pci))
2930 xc.num_pcidevs = C.int(numPcidevs)
2931 cPcidevs := (*[1<<28]C.libxl_device_pci)(unsafe.Pointer(xc.pcidevs))[:numPcidevs:numPcidevs]
2939 xc.rdms = (*C.libxl_device_rdm)(C.malloc(C.ulong(numRdms)*C.sizeof_libxl_device_rdm))
2940 xc.num_rdms = C.int(numRdms)
2941 cRdms := (*[1<<28]C.libxl_device_rdm)(unsafe.Pointer(xc.rdms))[:numRdms:numRdms]
2949 xc.dtdevs = (*C.libxl_device_dtdev)(C.malloc(C.ulong(numDtdevs)*C.sizeof_libxl_device_dtdev))
2950 xc.num_dtdevs = C.int(numDtdevs)
2951 cDtdevs := (*[1<<28]C.libxl_device_dtdev)(unsafe.Pointer(xc.dtdevs))[:numDtdevs:numDtdevs]
2959 xc.vfbs = (*C.libxl_device_vfb)(C.malloc(C.ulong(numVfbs)*C.sizeof_libxl_device_vfb))
2960 xc.num_vfbs = C.int(numVfbs)
2961 cVfbs := (*[1<<28]C.libxl_device_vfb)(unsafe.Pointer(xc.vfbs))[:numVfbs:numVfbs]
2969 xc.vkbs = (*C.libxl_device_vkb)(C.malloc(C.ulong(numVkbs)*C.sizeof_libxl_device_vkb))
2970 xc.num_vkbs = C.int(numVkbs)
2971 cVkbs := (*[1<<28]C.libxl_device_vkb)(unsafe.Pointer(xc.vkbs))[:numVkbs:numVkbs]
2979 xc.vtpms = (*C.libxl_device_vtpm)(C.malloc(C.ulong(numVtpms)*C.sizeof_libxl_device_vtpm))
2980 xc.num_vtpms = C.int(numVtpms)
2981 cVtpms := (*[1<<28]C.libxl_device_vtpm)(unsafe.Pointer(xc.vtpms))[:numVtpms:numVtpms]
2989 xc.p9s = (*C.libxl_device_p9)(C.malloc(C.ulong(numP9S)*C.sizeof_libxl_device_p9))
2990 xc.num_p9s = C.int(numP9S)
2991 cP9S := (*[1<<28]C.libxl_device_p9)(unsafe.Pointer(xc.p9s))[:numP9S:numP9S]
2999 xc.pvcallsifs = (*C.libxl_device_pvcallsif)(C.malloc(C.ulong(numPvcallsifs)*C.sizeof_libxl_device_p…
3000 xc.num_pvcallsifs = C.int(numPvcallsifs)
3001 cPvcallsifs := (*[1<<28]C.libxl_device_pvcallsif)(unsafe.Pointer(xc.pvcallsifs))[:numPvcallsifs:num…
3009 xc.vdispls = (*C.libxl_device_vdispl)(C.malloc(C.ulong(numVdispls)*C.sizeof_libxl_device_vdispl))
3010 xc.num_vdispls = C.int(numVdispls)
3011 cVdispls := (*[1<<28]C.libxl_device_vdispl)(unsafe.Pointer(xc.vdispls))[:numVdispls:numVdispls]
3019 xc.vsnds = (*C.libxl_device_vsnd)(C.malloc(C.ulong(numVsnds)*C.sizeof_libxl_device_vsnd))
3020 xc.num_vsnds = C.int(numVsnds)
3021 cVsnds := (*[1<<28]C.libxl_device_vsnd)(unsafe.Pointer(xc.vsnds))[:numVsnds:numVsnds]
3029 xc.channels = (*C.libxl_device_channel)(C.malloc(C.ulong(numChannels)*C.sizeof_libxl_device_channel…
3030 xc.num_channels = C.int(numChannels)
3031 cChannels := (*[1<<28]C.libxl_device_channel)(unsafe.Pointer(xc.channels))[:numChannels:numChannels]
3039 xc.usbctrls = (*C.libxl_device_usbctrl)(C.malloc(C.ulong(numUsbctrls)*C.sizeof_libxl_device_usbctrl…
3040 xc.num_usbctrls = C.int(numUsbctrls)
3041 cUsbctrls := (*[1<<28]C.libxl_device_usbctrl)(unsafe.Pointer(xc.usbctrls))[:numUsbctrls:numUsbctrls]
3049 xc.usbdevs = (*C.libxl_device_usbdev)(C.malloc(C.ulong(numUsbdevs)*C.sizeof_libxl_device_usbdev))
3050 xc.num_usbdevs = C.int(numUsbdevs)
3051 cUsbdevs := (*[1<<28]C.libxl_device_usbdev)(unsafe.Pointer(xc.usbdevs))[:numUsbdevs:numUsbdevs]
3058 xc.on_poweroff = C.libxl_action_on_shutdown(x.OnPoweroff)
3059 xc.on_reboot = C.libxl_action_on_shutdown(x.OnReboot)
3060 xc.on_watchdog = C.libxl_action_on_shutdown(x.OnWatchdog)
3061 xc.on_crash = C.libxl_action_on_shutdown(x.OnCrash)
3062 xc.on_soft_reset = C.libxl_action_on_shutdown(x.OnSoftReset)
3071 xc C.libxl_diskinfo)
3073 C.libxl_diskinfo_init(&xc)
3074 defer C.libxl_diskinfo_dispose(&xc)
3076 if err := x.fromC(&xc); err != nil {
3081 func (x *Diskinfo) fromC(xc *C.libxl_diskinfo) error {
3082 x.Backend = C.GoString(xc.backend)
3083 x.BackendId = uint32(xc.backend_id)
3084 x.Frontend = C.GoString(xc.frontend)
3085 x.FrontendId = uint32(xc.frontend_id)
3086 x.Devid = Devid(xc.devid)
3087 x.State = int(xc.state)
3088 x.Evtch = int(xc.evtch)
3089 x.Rref = int(xc.rref)
3093 func (x *Diskinfo) toC(xc *C.libxl_diskinfo) (err error){defer func(){
3095 C.libxl_diskinfo_dispose(xc)}
3099 xc.backend = C.CString(x.Backend)}
3100 xc.backend_id = C.uint32_t(x.BackendId)
3102 xc.frontend = C.CString(x.Frontend)}
3103 xc.frontend_id = C.uint32_t(x.FrontendId)
3104 xc.devid = C.libxl_devid(x.Devid)
3105 xc.state = C.int(x.State)
3106 xc.evtch = C.int(x.Evtch)
3107 xc.rref = C.int(x.Rref)
3116 xc C.libxl_nicinfo)
3118 C.libxl_nicinfo_init(&xc)
3119 defer C.libxl_nicinfo_dispose(&xc)
3121 if err := x.fromC(&xc); err != nil {
3126 func (x *Nicinfo) fromC(xc *C.libxl_nicinfo) error {
3127 x.Backend = C.GoString(xc.backend)
3128 x.BackendId = uint32(xc.backend_id)
3129 x.Frontend = C.GoString(xc.frontend)
3130 x.FrontendId = uint32(xc.frontend_id)
3131 x.Devid = Devid(xc.devid)
3132 x.State = int(xc.state)
3133 x.Evtch = int(xc.evtch)
3134 x.RrefTx = int(xc.rref_tx)
3135 x.RrefRx = int(xc.rref_rx)
3139 func (x *Nicinfo) toC(xc *C.libxl_nicinfo) (err error){defer func(){
3141 C.libxl_nicinfo_dispose(xc)}
3145 xc.backend = C.CString(x.Backend)}
3146 xc.backend_id = C.uint32_t(x.BackendId)
3148 xc.frontend = C.CString(x.Frontend)}
3149 xc.frontend_id = C.uint32_t(x.FrontendId)
3150 xc.devid = C.libxl_devid(x.Devid)
3151 xc.state = C.int(x.State)
3152 xc.evtch = C.int(x.Evtch)
3153 xc.rref_tx = C.int(x.RrefTx)
3154 xc.rref_rx = C.int(x.RrefRx)
3163 xc C.libxl_vtpminfo)
3165 C.libxl_vtpminfo_init(&xc)
3166 defer C.libxl_vtpminfo_dispose(&xc)
3168 if err := x.fromC(&xc); err != nil {
3173 func (x *Vtpminfo) fromC(xc *C.libxl_vtpminfo) error {
3174 x.Backend = C.GoString(xc.backend)
3175 x.BackendId = uint32(xc.backend_id)
3176 x.Frontend = C.GoString(xc.frontend)
3177 x.FrontendId = uint32(xc.frontend_id)
3178 x.Devid = Devid(xc.devid)
3179 x.State = int(xc.state)
3180 x.Evtch = int(xc.evtch)
3181 x.Rref = int(xc.rref)
3182 if err := x.Uuid.fromC(&xc.uuid);err != nil {
3188 func (x *Vtpminfo) toC(xc *C.libxl_vtpminfo) (err error){defer func(){
3190 C.libxl_vtpminfo_dispose(xc)}
3194 xc.backend = C.CString(x.Backend)}
3195 xc.backend_id = C.uint32_t(x.BackendId)
3197 xc.frontend = C.CString(x.Frontend)}
3198 xc.frontend_id = C.uint32_t(x.FrontendId)
3199 xc.devid = C.libxl_devid(x.Devid)
3200 xc.state = C.int(x.State)
3201 xc.evtch = C.int(x.Evtch)
3202 xc.rref = C.int(x.Rref)
3203 if err := x.Uuid.toC(&xc.uuid); err != nil {
3214 xc C.libxl_usbctrlinfo)
3216 C.libxl_usbctrlinfo_init(&xc)
3217 defer C.libxl_usbctrlinfo_dispose(&xc)
3219 if err := x.fromC(&xc); err != nil {
3224 func (x *Usbctrlinfo) fromC(xc *C.libxl_usbctrlinfo) error {
3225 x.Type = UsbctrlType(xc._type)
3226 x.Devid = Devid(xc.devid)
3227 x.Version = int(xc.version)
3228 x.Ports = int(xc.ports)
3229 x.Backend = C.GoString(xc.backend)
3230 x.BackendId = uint32(xc.backend_id)
3231 x.Frontend = C.GoString(xc.frontend)
3232 x.FrontendId = uint32(xc.frontend_id)
3233 x.State = int(xc.state)
3234 x.Evtch = int(xc.evtch)
3235 x.RefUrb = int(xc.ref_urb)
3236 x.RefConn = int(xc.ref_conn)
3240 func (x *Usbctrlinfo) toC(xc *C.libxl_usbctrlinfo) (err error){defer func(){
3242 C.libxl_usbctrlinfo_dispose(xc)}
3245 xc._type = C.libxl_usbctrl_type(x.Type)
3246 xc.devid = C.libxl_devid(x.Devid)
3247 xc.version = C.int(x.Version)
3248 xc.ports = C.int(x.Ports)
3250 xc.backend = C.CString(x.Backend)}
3251 xc.backend_id = C.uint32_t(x.BackendId)
3253 xc.frontend = C.CString(x.Frontend)}
3254 xc.frontend_id = C.uint32_t(x.FrontendId)
3255 xc.state = C.int(x.State)
3256 xc.evtch = C.int(x.Evtch)
3257 xc.ref_urb = C.int(x.RefUrb)
3258 xc.ref_conn = C.int(x.RefConn)
3267 xc C.libxl_vcpuinfo)
3269 C.libxl_vcpuinfo_init(&xc)
3270 defer C.libxl_vcpuinfo_dispose(&xc)
3272 if err := x.fromC(&xc); err != nil {
3277 func (x *Vcpuinfo) fromC(xc *C.libxl_vcpuinfo) error {
3278 x.Vcpuid = uint32(xc.vcpuid)
3279 x.Cpu = uint32(xc.cpu)
3280 x.Online = bool(xc.online)
3281 x.Blocked = bool(xc.blocked)
3282 x.Running = bool(xc.running)
3283 x.VcpuTime = uint64(xc.vcpu_time)
3284 if err := x.Cpumap.fromC(&xc.cpumap);err != nil {
3287 if err := x.CpumapSoft.fromC(&xc.cpumap_soft);err != nil {
3293 func (x *Vcpuinfo) toC(xc *C.libxl_vcpuinfo) (err error){defer func(){
3295 C.libxl_vcpuinfo_dispose(xc)}
3298 xc.vcpuid = C.uint32_t(x.Vcpuid)
3299 xc.cpu = C.uint32_t(x.Cpu)
3300 xc.online = C.bool(x.Online)
3301 xc.blocked = C.bool(x.Blocked)
3302 xc.running = C.bool(x.Running)
3303 xc.vcpu_time = C.uint64_t(x.VcpuTime)
3304 if err := x.Cpumap.toC(&xc.cpumap); err != nil {
3307 if err := x.CpumapSoft.toC(&xc.cpumap_soft); err != nil {
3318 xc C.libxl_physinfo)
3320 C.libxl_physinfo_init(&xc)
3321 defer C.libxl_physinfo_dispose(&xc)
3323 if err := x.fromC(&xc); err != nil {
3328 func (x *Physinfo) fromC(xc *C.libxl_physinfo) error {
3329 x.ThreadsPerCore = uint32(xc.threads_per_core)
3330 x.CoresPerSocket = uint32(xc.cores_per_socket)
3331 x.MaxCpuId = uint32(xc.max_cpu_id)
3332 x.NrCpus = uint32(xc.nr_cpus)
3333 x.CpuKhz = uint32(xc.cpu_khz)
3334 x.TotalPages = uint64(xc.total_pages)
3335 x.FreePages = uint64(xc.free_pages)
3336 x.ScrubPages = uint64(xc.scrub_pages)
3337 x.OutstandingPages = uint64(xc.outstanding_pages)
3338 x.SharingFreedPages = uint64(xc.sharing_freed_pages)
3339 x.SharingUsedFrames = uint64(xc.sharing_used_frames)
3340 x.MaxPossibleMfn = uint64(xc.max_possible_mfn)
3341 x.NrNodes = uint32(xc.nr_nodes)
3342 if err := x.HwCap.fromC(&xc.hw_cap);err != nil {
3345 x.CapHvm = bool(xc.cap_hvm)
3346 x.CapPv = bool(xc.cap_pv)
3347 x.CapHvmDirectio = bool(xc.cap_hvm_directio)
3348 x.CapHap = bool(xc.cap_hap)
3349 x.CapShadow = bool(xc.cap_shadow)
3350 x.CapIommuHapPtShare = bool(xc.cap_iommu_hap_pt_share)
3354 func (x *Physinfo) toC(xc *C.libxl_physinfo) (err error){defer func(){
3356 C.libxl_physinfo_dispose(xc)}
3359 xc.threads_per_core = C.uint32_t(x.ThreadsPerCore)
3360 xc.cores_per_socket = C.uint32_t(x.CoresPerSocket)
3361 xc.max_cpu_id = C.uint32_t(x.MaxCpuId)
3362 xc.nr_cpus = C.uint32_t(x.NrCpus)
3363 xc.cpu_khz = C.uint32_t(x.CpuKhz)
3364 xc.total_pages = C.uint64_t(x.TotalPages)
3365 xc.free_pages = C.uint64_t(x.FreePages)
3366 xc.scrub_pages = C.uint64_t(x.ScrubPages)
3367 xc.outstanding_pages = C.uint64_t(x.OutstandingPages)
3368 xc.sharing_freed_pages = C.uint64_t(x.SharingFreedPages)
3369 xc.sharing_used_frames = C.uint64_t(x.SharingUsedFrames)
3370 xc.max_possible_mfn = C.uint64_t(x.MaxPossibleMfn)
3371 xc.nr_nodes = C.uint32_t(x.NrNodes)
3372 if err := x.HwCap.toC(&xc.hw_cap); err != nil {
3375 xc.cap_hvm = C.bool(x.CapHvm)
3376 xc.cap_pv = C.bool(x.CapPv)
3377 xc.cap_hvm_directio = C.bool(x.CapHvmDirectio)
3378 xc.cap_hap = C.bool(x.CapHap)
3379 xc.cap_shadow = C.bool(x.CapShadow)
3380 xc.cap_iommu_hap_pt_share = C.bool(x.CapIommuHapPtShare)
3389 xc C.libxl_connectorinfo)
3391 C.libxl_connectorinfo_init(&xc)
3392 defer C.libxl_connectorinfo_dispose(&xc)
3394 if err := x.fromC(&xc); err != nil {
3399 func (x *Connectorinfo) fromC(xc *C.libxl_connectorinfo) error {
3400 x.UniqueId = C.GoString(xc.unique_id)
3401 x.Width = uint32(xc.width)
3402 x.Height = uint32(xc.height)
3403 x.ReqEvtch = int(xc.req_evtch)
3404 x.ReqRref = int(xc.req_rref)
3405 x.EvtEvtch = int(xc.evt_evtch)
3406 x.EvtRref = int(xc.evt_rref)
3410 func (x *Connectorinfo) toC(xc *C.libxl_connectorinfo) (err error){defer func(){
3412 C.libxl_connectorinfo_dispose(xc)}
3416 xc.unique_id = C.CString(x.UniqueId)}
3417 xc.width = C.uint32_t(x.Width)
3418 xc.height = C.uint32_t(x.Height)
3419 xc.req_evtch = C.int(x.ReqEvtch)
3420 xc.req_rref = C.int(x.ReqRref)
3421 xc.evt_evtch = C.int(x.EvtEvtch)
3422 xc.evt_rref = C.int(x.EvtRref)
3431 xc C.libxl_vdisplinfo)
3433 C.libxl_vdisplinfo_init(&xc)
3434 defer C.libxl_vdisplinfo_dispose(&xc)
3436 if err := x.fromC(&xc); err != nil {
3441 func (x *Vdisplinfo) fromC(xc *C.libxl_vdisplinfo) error {
3442 x.Backend = C.GoString(xc.backend)
3443 x.BackendId = uint32(xc.backend_id)
3444 x.Frontend = C.GoString(xc.frontend)
3445 x.FrontendId = uint32(xc.frontend_id)
3446 x.Devid = Devid(xc.devid)
3447 x.State = int(xc.state)
3448 x.BeAlloc = bool(xc.be_alloc)
3450 if n := int(xc.num_connectors); n > 0 {
3451 cConnectors := (*[1<<28]C.libxl_connectorinfo)(unsafe.Pointer(xc.connectors))[:n:n]
3461 func (x *Vdisplinfo) toC(xc *C.libxl_vdisplinfo) (err error){defer func(){
3463 C.libxl_vdisplinfo_dispose(xc)}
3467 xc.backend = C.CString(x.Backend)}
3468 xc.backend_id = C.uint32_t(x.BackendId)
3470 xc.frontend = C.CString(x.Frontend)}
3471 xc.frontend_id = C.uint32_t(x.FrontendId)
3472 xc.devid = C.libxl_devid(x.Devid)
3473 xc.state = C.int(x.State)
3474 xc.be_alloc = C.bool(x.BeAlloc)
3476 xc.connectors = (*C.libxl_connectorinfo)(C.malloc(C.ulong(numConnectors)*C.sizeof_libxl_connectorin…
3477 xc.num_connectors = C.int(numConnectors)
3478 cConnectors := (*[1<<28]C.libxl_connectorinfo)(unsafe.Pointer(xc.connectors))[:numConnectors:numCon…
3493 xc C.libxl_streaminfo)
3495 C.libxl_streaminfo_init(&xc)
3496 defer C.libxl_streaminfo_dispose(&xc)
3498 if err := x.fromC(&xc); err != nil {
3503 func (x *Streaminfo) fromC(xc *C.libxl_streaminfo) error {
3504 x.ReqEvtch = int(xc.req_evtch)
3505 x.ReqRref = int(xc.req_rref)
3509 func (x *Streaminfo) toC(xc *C.libxl_streaminfo) (err error){defer func(){
3511 C.libxl_streaminfo_dispose(xc)}
3514 xc.req_evtch = C.int(x.ReqEvtch)
3515 xc.req_rref = C.int(x.ReqRref)
3524 xc C.libxl_pcminfo)
3526 C.libxl_pcminfo_init(&xc)
3527 defer C.libxl_pcminfo_dispose(&xc)
3529 if err := x.fromC(&xc); err != nil {
3534 func (x *Pcminfo) fromC(xc *C.libxl_pcminfo) error {
3536 if n := int(xc.num_vsnd_streams); n > 0 {
3537 cStreams := (*[1<<28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))[:n:n]
3547 func (x *Pcminfo) toC(xc *C.libxl_pcminfo) (err error){defer func(){
3549 C.libxl_pcminfo_dispose(xc)}
3553 xc.streams = (*C.libxl_streaminfo)(C.malloc(C.ulong(numVsndStreams)*C.sizeof_libxl_streaminfo))
3554 xc.num_vsnd_streams = C.int(numVsndStreams)
3555 cStreams := (*[1<<28]C.libxl_streaminfo)(unsafe.Pointer(xc.streams))[:numVsndStreams:numVsndStreams]
3570 xc C.libxl_vsndinfo)
3572 C.libxl_vsndinfo_init(&xc)
3573 defer C.libxl_vsndinfo_dispose(&xc)
3575 if err := x.fromC(&xc); err != nil {
3580 func (x *Vsndinfo) fromC(xc *C.libxl_vsndinfo) error {
3581 x.Backend = C.GoString(xc.backend)
3582 x.BackendId = uint32(xc.backend_id)
3583 x.Frontend = C.GoString(xc.frontend)
3584 x.FrontendId = uint32(xc.frontend_id)
3585 x.Devid = Devid(xc.devid)
3586 x.State = int(xc.state)
3588 if n := int(xc.num_vsnd_pcms); n > 0 {
3589 cPcms := (*[1<<28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:n:n]
3599 func (x *Vsndinfo) toC(xc *C.libxl_vsndinfo) (err error){defer func(){
3601 C.libxl_vsndinfo_dispose(xc)}
3605 xc.backend = C.CString(x.Backend)}
3606 xc.backend_id = C.uint32_t(x.BackendId)
3608 xc.frontend = C.CString(x.Frontend)}
3609 xc.frontend_id = C.uint32_t(x.FrontendId)
3610 xc.devid = C.libxl_devid(x.Devid)
3611 xc.state = C.int(x.State)
3613 xc.pcms = (*C.libxl_pcminfo)(C.malloc(C.ulong(numVsndPcms)*C.sizeof_libxl_pcminfo))
3614 xc.num_vsnd_pcms = C.int(numVsndPcms)
3615 cPcms := (*[1<<28]C.libxl_pcminfo)(unsafe.Pointer(xc.pcms))[:numVsndPcms:numVsndPcms]
3630 xc C.libxl_vkbinfo)
3632 C.libxl_vkbinfo_init(&xc)
3633 defer C.libxl_vkbinfo_dispose(&xc)
3635 if err := x.fromC(&xc); err != nil {
3640 func (x *Vkbinfo) fromC(xc *C.libxl_vkbinfo) error {
3641 x.Backend = C.GoString(xc.backend)
3642 x.BackendId = uint32(xc.backend_id)
3643 x.Frontend = C.GoString(xc.frontend)
3644 x.FrontendId = uint32(xc.frontend_id)
3645 x.Devid = Devid(xc.devid)
3646 x.State = int(xc.state)
3647 x.Evtch = int(xc.evtch)
3648 x.Rref = int(xc.rref)
3652 func (x *Vkbinfo) toC(xc *C.libxl_vkbinfo) (err error){defer func(){
3654 C.libxl_vkbinfo_dispose(xc)}
3658 xc.backend = C.CString(x.Backend)}
3659 xc.backend_id = C.uint32_t(x.BackendId)
3661 xc.frontend = C.CString(x.Frontend)}
3662 xc.frontend_id = C.uint32_t(x.FrontendId)
3663 xc.devid = C.libxl_devid(x.Devid)
3664 xc.state = C.int(x.State)
3665 xc.evtch = C.int(x.Evtch)
3666 xc.rref = C.int(x.Rref)
3675 xc C.libxl_numainfo)
3677 C.libxl_numainfo_init(&xc)
3678 defer C.libxl_numainfo_dispose(&xc)
3680 if err := x.fromC(&xc); err != nil {
3685 func (x *Numainfo) fromC(xc *C.libxl_numainfo) error {
3686 x.Size = uint64(xc.size)
3687 x.Free = uint64(xc.free)
3689 if n := int(xc.num_dists); n > 0 {
3690 cDists := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.dists))[:n:n]
3699 func (x *Numainfo) toC(xc *C.libxl_numainfo) (err error){defer func(){
3701 C.libxl_numainfo_dispose(xc)}
3704 xc.size = C.uint64_t(x.Size)
3705 xc.free = C.uint64_t(x.Free)
3707 xc.dists = (*C.uint32_t)(C.malloc(C.size_t(numDists*numDists)))
3708 xc.num_dists = C.int(numDists)
3709 cDists := (*[1<<28]C.uint32_t)(unsafe.Pointer(xc.dists))[:numDists:numDists]
3722 xc C.libxl_cputopology)
3724 C.libxl_cputopology_init(&xc)
3725 defer C.libxl_cputopology_dispose(&xc)
3727 if err := x.fromC(&xc); err != nil {
3732 func (x *Cputopology) fromC(xc *C.libxl_cputopology) error {
3733 x.Core = uint32(xc.core)
3734 x.Socket = uint32(xc.socket)
3735 x.Node = uint32(xc.node)
3739 func (x *Cputopology) toC(xc *C.libxl_cputopology) (err error){defer func(){
3741 C.libxl_cputopology_dispose(xc)}
3744 xc.core = C.uint32_t(x.Core)
3745 xc.socket = C.uint32_t(x.Socket)
3746 xc.node = C.uint32_t(x.Node)
3755 xc C.libxl_pcitopology)
3757 C.libxl_pcitopology_init(&xc)
3758 defer C.libxl_pcitopology_dispose(&xc)
3760 if err := x.fromC(&xc); err != nil {
3765 func (x *Pcitopology) fromC(xc *C.libxl_pcitopology) error {
3766 x.Seg = uint16(xc.seg)
3767 x.Bus = byte(xc.bus)
3768 x.Devfn = byte(xc.devfn)
3769 x.Node = uint32(xc.node)
3773 func (x *Pcitopology) toC(xc *C.libxl_pcitopology) (err error){defer func(){
3775 C.libxl_pcitopology_dispose(xc)}
3778 xc.seg = C.uint16_t(x.Seg)
3779 xc.bus = C.uint8_t(x.Bus)
3780 xc.devfn = C.uint8_t(x.Devfn)
3781 xc.node = C.uint32_t(x.Node)
3790 xc C.libxl_sched_credit_params)
3792 C.libxl_sched_credit_params_init(&xc)
3794 if err := x.fromC(&xc); err != nil {
3799 func (x *SchedCreditParams) fromC(xc *C.libxl_sched_credit_params) error {
3800 x.TsliceMs = int(xc.tslice_ms)
3801 x.RatelimitUs = int(xc.ratelimit_us)
3802 x.VcpuMigrDelayUs = int(xc.vcpu_migr_delay_us)
3806 func (x *SchedCreditParams) toC(xc *C.libxl_sched_credit_params) (err error){xc.tslice_ms = C.int(x…
3807 xc.ratelimit_us = C.int(x.RatelimitUs)
3808 xc.vcpu_migr_delay_us = C.int(x.VcpuMigrDelayUs)
3817 xc C.libxl_sched_credit2_params)
3819 C.libxl_sched_credit2_params_init(&xc)
3821 if err := x.fromC(&xc); err != nil {
3826 func (x *SchedCredit2Params) fromC(xc *C.libxl_sched_credit2_params) error {
3827 x.RatelimitUs = int(xc.ratelimit_us)
3831 func (x *SchedCredit2Params) toC(xc *C.libxl_sched_credit2_params) (err error){xc.ratelimit_us = C.…
3840 xc C.libxl_domain_remus_info)
3842 C.libxl_domain_remus_info_init(&xc)
3843 defer C.libxl_domain_remus_info_dispose(&xc)
3845 if err := x.fromC(&xc); err != nil {
3850 func (x *DomainRemusInfo) fromC(xc *C.libxl_domain_remus_info) error {
3851 x.Interval = int(xc.interval)
3852 if err := x.AllowUnsafe.fromC(&xc.allow_unsafe);err != nil {
3855 if err := x.Blackhole.fromC(&xc.blackhole);err != nil {
3858 if err := x.Compression.fromC(&xc.compression);err != nil {
3861 if err := x.Netbuf.fromC(&xc.netbuf);err != nil {
3864 x.Netbufscript = C.GoString(xc.netbufscript)
3865 if err := x.Diskbuf.fromC(&xc.diskbuf);err != nil {
3868 if err := x.Colo.fromC(&xc.colo);err != nil {
3871 if err := x.UserspaceColoProxy.fromC(&xc.userspace_colo_proxy);err != nil {
3877 func (x *DomainRemusInfo) toC(xc *C.libxl_domain_remus_info) (err error){defer func(){
3879 C.libxl_domain_remus_info_dispose(xc)}
3882 xc.interval = C.int(x.Interval)
3883 if err := x.AllowUnsafe.toC(&xc.allow_unsafe); err != nil {
3886 if err := x.Blackhole.toC(&xc.blackhole); err != nil {
3889 if err := x.Compression.toC(&xc.compression); err != nil {
3892 if err := x.Netbuf.toC(&xc.netbuf); err != nil {
3896 xc.netbufscript = C.CString(x.Netbufscript)}
3897 if err := x.Diskbuf.toC(&xc.diskbuf); err != nil {
3900 if err := x.Colo.toC(&xc.colo); err != nil {
3903 if err := x.UserspaceColoProxy.toC(&xc.userspace_colo_proxy); err != nil {
3914 xc C.libxl_event)
3916 C.libxl_event_init(&xc)
3917 C.libxl_event_init_type(&xc, C.libxl_event_type(etype))
3918 defer C.libxl_event_dispose(&xc)
3920 if err := x.fromC(&xc); err != nil {
3925 func (x *Event) fromC(xc *C.libxl_event) error {
3926 if err := x.Link.fromC(&xc.link);err != nil {
3929 x.Domid = Domid(xc.domid)
3930 if err := x.Domuuid.fromC(&xc.domuuid);err != nil {
3933 x.ForUser = uint64(xc.for_user)
3934 x.Type = EventType(xc._type)
3938 if err := typeDiskEject.fromC(xc);err != nil {
3948 if err := typeDomainShutdown.fromC(xc);err != nil {
3954 if err := typeOperationComplete.fromC(xc);err != nil {
3963 func (x *EventTypeUnionDomainShutdown) fromC(xc *C.libxl_event) error {
3964 if EventType(xc._type) != EventTypeDomainShutdown {
3968 tmp := (*C.libxl_event_type_union_domain_shutdown)(unsafe.Pointer(&xc.u[0]))
3973 func (x *EventTypeUnionDiskEject) fromC(xc *C.libxl_event) error {
3974 if EventType(xc._type) != EventTypeDiskEject {
3978 tmp := (*C.libxl_event_type_union_disk_eject)(unsafe.Pointer(&xc.u[0]))
3986 func (x *EventTypeUnionOperationComplete) fromC(xc *C.libxl_event) error {
3987 if EventType(xc._type) != EventTypeOperationComplete {
3991 tmp := (*C.libxl_event_type_union_operation_complete)(unsafe.Pointer(&xc.u[0]))
3996 func (x *Event) toC(xc *C.libxl_event) (err error){defer func(){
3998 C.libxl_event_dispose(xc)}
4001 if err := x.Link.toC(&xc.link); err != nil {
4004 xc.domid = C.libxl_domid(x.Domid)
4005 if err := x.Domuuid.toC(&xc.domuuid); err != nil {
4008 xc.for_user = C.uint64_t(x.ForUser)
4009 xc._type = C.libxl_event_type(x.Type)
4019 copy(xc.u[:],domain_shutdownBytes)
4034 copy(xc.u[:],disk_ejectBytes)
4043 copy(xc.u[:],operation_completeBytes)
4056 xc C.libxl_psr_cat_info)
4058 C.libxl_psr_cat_info_init(&xc)
4059 defer C.libxl_psr_cat_info_dispose(&xc)
4061 if err := x.fromC(&xc); err != nil {
4066 func (x *PsrCatInfo) fromC(xc *C.libxl_psr_cat_info) error {
4067 x.Id = uint32(xc.id)
4068 x.CosMax = uint32(xc.cos_max)
4069 x.CbmLen = uint32(xc.cbm_len)
4070 x.CdpEnabled = bool(xc.cdp_enabled)
4074 func (x *PsrCatInfo) toC(xc *C.libxl_psr_cat_info) (err error){defer func(){
4076 C.libxl_psr_cat_info_dispose(xc)}
4079 xc.id = C.uint32_t(x.Id)
4080 xc.cos_max = C.uint32_t(x.CosMax)
4081 xc.cbm_len = C.uint32_t(x.CbmLen)
4082 xc.cdp_enabled = C.bool(x.CdpEnabled)
4091 xc C.libxl_psr_hw_info)
4093 C.libxl_psr_hw_info_init(&xc)
4094 C.libxl_psr_hw_info_init_type(&xc, C.libxl_psr_feat_type(ptype))
4095 defer C.libxl_psr_hw_info_dispose(&xc)
4097 if err := x.fromC(&xc); err != nil {
4102 func (x *PsrHwInfo) fromC(xc *C.libxl_psr_hw_info) error {
4103 x.Id = uint32(xc.id)
4104 x.Type = PsrFeatType(xc._type)
4108 if err := typeCat.fromC(xc);err != nil {
4114 if err := typeMba.fromC(xc);err != nil {
4123 func (x *PsrHwInfoTypeUnionCat) fromC(xc *C.libxl_psr_hw_info) error {
4124 if PsrFeatType(xc._type) != PsrFeatTypeCat {
4128 tmp := (*C.libxl_psr_hw_info_type_union_cat)(unsafe.Pointer(&xc.u[0]))
4135 func (x *PsrHwInfoTypeUnionMba) fromC(xc *C.libxl_psr_hw_info) error {
4136 if PsrFeatType(xc._type) != PsrFeatTypeMba {
4140 tmp := (*C.libxl_psr_hw_info_type_union_mba)(unsafe.Pointer(&xc.u[0]))
4147 func (x *PsrHwInfo) toC(xc *C.libxl_psr_hw_info) (err error){defer func(){
4149 C.libxl_psr_hw_info_dispose(xc)}
4152 xc.id = C.uint32_t(x.Id)
4153 xc._type = C.libxl_psr_feat_type(x.Type)
4165 copy(xc.u[:],catBytes)
4176 copy(xc.u[:],mbaBytes)