source: trunk/packages/xen-3.1/xen-3.1/tools/libxen/src/xen_vm.c @ 34

Last change on this file since 34 was 34, checked in by hartmans, 18 years ago

Add xen and xen-common

File size: 43.8 KB
Line 
1/*
2 * Copyright (c) 2006-2007, XenSource Inc.
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
17 */
18
19
20#include <stddef.h>
21#include <stdlib.h>
22
23#include "xen_internal.h"
24#include "xen_on_crash_behaviour_internal.h"
25#include "xen_on_normal_exit_internal.h"
26#include "xen_vm_power_state_internal.h"
27#include <xen/api/xen_common.h>
28#include <xen/api/xen_console.h>
29#include <xen/api/xen_crashdump.h>
30#include <xen/api/xen_host.h>
31#include <xen/api/xen_string_string_map.h>
32#include <xen/api/xen_vbd.h>
33#include <xen/api/xen_vdi.h>
34#include <xen/api/xen_vif.h>
35#include <xen/api/xen_vm.h>
36#include <xen/api/xen_vm_guest_metrics.h>
37#include <xen/api/xen_vm_metrics.h>
38#include <xen/api/xen_vtpm.h>
39
40
41XEN_FREE(xen_vm)
42XEN_SET_ALLOC_FREE(xen_vm)
43XEN_ALLOC(xen_vm_record)
44XEN_SET_ALLOC_FREE(xen_vm_record)
45XEN_ALLOC(xen_vm_record_opt)
46XEN_RECORD_OPT_FREE(xen_vm)
47XEN_SET_ALLOC_FREE(xen_vm_record_opt)
48
49
50static const struct_member xen_vm_record_struct_members[] =
51    {
52        { .key = "uuid",
53          .type = &abstract_type_string,
54          .offset = offsetof(xen_vm_record, uuid) },
55        { .key = "power_state",
56          .type = &xen_vm_power_state_abstract_type_,
57          .offset = offsetof(xen_vm_record, power_state) },
58        { .key = "name_label",
59          .type = &abstract_type_string,
60          .offset = offsetof(xen_vm_record, name_label) },
61        { .key = "name_description",
62          .type = &abstract_type_string,
63          .offset = offsetof(xen_vm_record, name_description) },
64        { .key = "user_version",
65          .type = &abstract_type_int,
66          .offset = offsetof(xen_vm_record, user_version) },
67        { .key = "is_a_template",
68          .type = &abstract_type_bool,
69          .offset = offsetof(xen_vm_record, is_a_template) },
70        { .key = "auto_power_on",
71          .type = &abstract_type_bool,
72          .offset = offsetof(xen_vm_record, auto_power_on) },
73        { .key = "suspend_VDI",
74          .type = &abstract_type_ref,
75          .offset = offsetof(xen_vm_record, suspend_vdi) },
76        { .key = "resident_on",
77          .type = &abstract_type_ref,
78          .offset = offsetof(xen_vm_record, resident_on) },
79        { .key = "memory_static_max",
80          .type = &abstract_type_int,
81          .offset = offsetof(xen_vm_record, memory_static_max) },
82        { .key = "memory_dynamic_max",
83          .type = &abstract_type_int,
84          .offset = offsetof(xen_vm_record, memory_dynamic_max) },
85        { .key = "memory_dynamic_min",
86          .type = &abstract_type_int,
87          .offset = offsetof(xen_vm_record, memory_dynamic_min) },
88        { .key = "memory_static_min",
89          .type = &abstract_type_int,
90          .offset = offsetof(xen_vm_record, memory_static_min) },
91        { .key = "VCPUs_params",
92          .type = &abstract_type_string_string_map,
93          .offset = offsetof(xen_vm_record, vcpus_params) },
94        { .key = "VCPUs_max",
95          .type = &abstract_type_int,
96          .offset = offsetof(xen_vm_record, vcpus_max) },
97        { .key = "VCPUs_at_startup",
98          .type = &abstract_type_int,
99          .offset = offsetof(xen_vm_record, vcpus_at_startup) },
100        { .key = "actions_after_shutdown",
101          .type = &xen_on_normal_exit_abstract_type_,
102          .offset = offsetof(xen_vm_record, actions_after_shutdown) },
103        { .key = "actions_after_reboot",
104          .type = &xen_on_normal_exit_abstract_type_,
105          .offset = offsetof(xen_vm_record, actions_after_reboot) },
106        { .key = "actions_after_crash",
107          .type = &xen_on_crash_behaviour_abstract_type_,
108          .offset = offsetof(xen_vm_record, actions_after_crash) },
109        { .key = "consoles",
110          .type = &abstract_type_ref_set,
111          .offset = offsetof(xen_vm_record, consoles) },
112        { .key = "VIFs",
113          .type = &abstract_type_ref_set,
114          .offset = offsetof(xen_vm_record, vifs) },
115        { .key = "VBDs",
116          .type = &abstract_type_ref_set,
117          .offset = offsetof(xen_vm_record, vbds) },
118        { .key = "crash_dumps",
119          .type = &abstract_type_ref_set,
120          .offset = offsetof(xen_vm_record, crash_dumps) },
121        { .key = "VTPMs",
122          .type = &abstract_type_ref_set,
123          .offset = offsetof(xen_vm_record, vtpms) },
124        { .key = "PV_bootloader",
125          .type = &abstract_type_string,
126          .offset = offsetof(xen_vm_record, pv_bootloader) },
127        { .key = "PV_kernel",
128          .type = &abstract_type_string,
129          .offset = offsetof(xen_vm_record, pv_kernel) },
130        { .key = "PV_ramdisk",
131          .type = &abstract_type_string,
132          .offset = offsetof(xen_vm_record, pv_ramdisk) },
133        { .key = "PV_args",
134          .type = &abstract_type_string,
135          .offset = offsetof(xen_vm_record, pv_args) },
136        { .key = "PV_bootloader_args",
137          .type = &abstract_type_string,
138          .offset = offsetof(xen_vm_record, pv_bootloader_args) },
139        { .key = "HVM_boot_policy",
140          .type = &abstract_type_string,
141          .offset = offsetof(xen_vm_record, hvm_boot_policy) },
142        { .key = "HVM_boot_params",
143          .type = &abstract_type_string_string_map,
144          .offset = offsetof(xen_vm_record, hvm_boot_params) },
145        { .key = "platform",
146          .type = &abstract_type_string_string_map,
147          .offset = offsetof(xen_vm_record, platform) },
148        { .key = "PCI_bus",
149          .type = &abstract_type_string,
150          .offset = offsetof(xen_vm_record, pci_bus) },
151        { .key = "other_config",
152          .type = &abstract_type_string_string_map,
153          .offset = offsetof(xen_vm_record, other_config) },
154        { .key = "domid",
155          .type = &abstract_type_int,
156          .offset = offsetof(xen_vm_record, domid) },
157        { .key = "is_control_domain",
158          .type = &abstract_type_bool,
159          .offset = offsetof(xen_vm_record, is_control_domain) },
160        { .key = "metrics",
161          .type = &abstract_type_ref,
162          .offset = offsetof(xen_vm_record, metrics) },
163        { .key = "guest_metrics",
164          .type = &abstract_type_ref,
165          .offset = offsetof(xen_vm_record, guest_metrics) }
166    };
167
168const abstract_type xen_vm_record_abstract_type_ =
169    {
170       .typename = STRUCT,
171       .struct_size = sizeof(xen_vm_record),
172       .member_count =
173           sizeof(xen_vm_record_struct_members) / sizeof(struct_member),
174       .members = xen_vm_record_struct_members
175    };
176
177
178void
179xen_vm_record_free(xen_vm_record *record)
180{
181    if (record == NULL)
182    {
183        return;
184    }
185    free(record->handle);
186    free(record->uuid);
187    free(record->name_label);
188    free(record->name_description);
189    xen_vdi_record_opt_free(record->suspend_vdi);
190    xen_host_record_opt_free(record->resident_on);
191    xen_string_string_map_free(record->vcpus_params);
192    xen_console_record_opt_set_free(record->consoles);
193    xen_vif_record_opt_set_free(record->vifs);
194    xen_vbd_record_opt_set_free(record->vbds);
195    xen_crashdump_record_opt_set_free(record->crash_dumps);
196    xen_vtpm_record_opt_set_free(record->vtpms);
197    free(record->pv_bootloader);
198    free(record->pv_kernel);
199    free(record->pv_ramdisk);
200    free(record->pv_args);
201    free(record->pv_bootloader_args);
202    free(record->hvm_boot_policy);
203    xen_string_string_map_free(record->hvm_boot_params);
204    xen_string_string_map_free(record->platform);
205    free(record->pci_bus);
206    xen_string_string_map_free(record->other_config);
207    xen_vm_metrics_record_opt_free(record->metrics);
208    xen_vm_guest_metrics_record_opt_free(record->guest_metrics);
209    free(record);
210}
211
212
213bool
214xen_vm_get_record(xen_session *session, xen_vm_record **result, xen_vm vm)
215{
216    abstract_value param_values[] =
217        {
218            { .type = &abstract_type_string,
219              .u.string_val = vm }
220        };
221
222    abstract_type result_type = xen_vm_record_abstract_type_;
223
224    *result = NULL;
225    XEN_CALL_("VM.get_record");
226
227    if (session->ok)
228    {
229       (*result)->handle = xen_strdup_((*result)->uuid);
230    }
231
232    return session->ok;
233}
234
235
236bool
237xen_vm_get_by_uuid(xen_session *session, xen_vm *result, char *uuid)
238{
239    abstract_value param_values[] =
240        {
241            { .type = &abstract_type_string,
242              .u.string_val = uuid }
243        };
244
245    abstract_type result_type = abstract_type_string;
246
247    *result = NULL;
248    XEN_CALL_("VM.get_by_uuid");
249    return session->ok;
250}
251
252
253bool
254xen_vm_create(xen_session *session, xen_vm *result, xen_vm_record *record)
255{
256    abstract_value param_values[] =
257        {
258            { .type = &xen_vm_record_abstract_type_,
259              .u.struct_val = record }
260        };
261
262    abstract_type result_type = abstract_type_string;
263
264    *result = NULL;
265    XEN_CALL_("VM.create");
266    return session->ok;
267}
268
269
270bool
271xen_vm_destroy(xen_session *session, xen_vm vm)
272{
273    abstract_value param_values[] =
274        {
275            { .type = &abstract_type_string,
276              .u.string_val = vm }
277        };
278
279    xen_call_(session, "VM.destroy", param_values, 1, NULL, NULL);
280    return session->ok;
281}
282
283
284bool
285xen_vm_get_by_name_label(xen_session *session, struct xen_vm_set **result, char *label)
286{
287    abstract_value param_values[] =
288        {
289            { .type = &abstract_type_string,
290              .u.string_val = label }
291        };
292
293    abstract_type result_type = abstract_type_string_set;
294
295    *result = NULL;
296    XEN_CALL_("VM.get_by_name_label");
297    return session->ok;
298}
299
300
301bool
302xen_vm_get_power_state(xen_session *session, enum xen_vm_power_state *result, xen_vm vm)
303{
304    abstract_value param_values[] =
305        {
306            { .type = &abstract_type_string,
307              .u.string_val = vm }
308        };
309
310    abstract_type result_type = xen_vm_power_state_abstract_type_;
311    XEN_CALL_("VM.get_power_state");
312    return session->ok;
313}
314
315
316bool
317xen_vm_get_name_label(xen_session *session, char **result, xen_vm vm)
318{
319    abstract_value param_values[] =
320        {
321            { .type = &abstract_type_string,
322              .u.string_val = vm }
323        };
324
325    abstract_type result_type = abstract_type_string;
326
327    *result = NULL;
328    XEN_CALL_("VM.get_name_label");
329    return session->ok;
330}
331
332
333bool
334xen_vm_get_name_description(xen_session *session, char **result, xen_vm vm)
335{
336    abstract_value param_values[] =
337        {
338            { .type = &abstract_type_string,
339              .u.string_val = vm }
340        };
341
342    abstract_type result_type = abstract_type_string;
343
344    *result = NULL;
345    XEN_CALL_("VM.get_name_description");
346    return session->ok;
347}
348
349
350bool
351xen_vm_get_user_version(xen_session *session, int64_t *result, xen_vm vm)
352{
353    abstract_value param_values[] =
354        {
355            { .type = &abstract_type_string,
356              .u.string_val = vm }
357        };
358
359    abstract_type result_type = abstract_type_int;
360
361    XEN_CALL_("VM.get_user_version");
362    return session->ok;
363}
364
365
366bool
367xen_vm_get_is_a_template(xen_session *session, bool *result, xen_vm vm)
368{
369    abstract_value param_values[] =
370        {
371            { .type = &abstract_type_string,
372              .u.string_val = vm }
373        };
374
375    abstract_type result_type = abstract_type_bool;
376
377    XEN_CALL_("VM.get_is_a_template");
378    return session->ok;
379}
380
381
382bool
383xen_vm_get_auto_power_on(xen_session *session, bool *result, xen_vm vm)
384{
385    abstract_value param_values[] =
386        {
387            { .type = &abstract_type_string,
388              .u.string_val = vm }
389        };
390
391    abstract_type result_type = abstract_type_bool;
392
393    XEN_CALL_("VM.get_auto_power_on");
394    return session->ok;
395}
396
397
398bool
399xen_vm_get_suspend_vdi(xen_session *session, xen_vdi *result, xen_vm vm)
400{
401    abstract_value param_values[] =
402        {
403            { .type = &abstract_type_string,
404              .u.string_val = vm }
405        };
406
407    abstract_type result_type = abstract_type_string;
408
409    *result = NULL;
410    XEN_CALL_("VM.get_suspend_VDI");
411    return session->ok;
412}
413
414
415bool
416xen_vm_get_resident_on(xen_session *session, xen_host *result, xen_vm vm)
417{
418    abstract_value param_values[] =
419        {
420            { .type = &abstract_type_string,
421              .u.string_val = vm }
422        };
423
424    abstract_type result_type = abstract_type_string;
425
426    *result = NULL;
427    XEN_CALL_("VM.get_resident_on");
428    return session->ok;
429}
430
431
432bool
433xen_vm_get_memory_static_max(xen_session *session, int64_t *result, xen_vm vm)
434{
435    abstract_value param_values[] =
436        {
437            { .type = &abstract_type_string,
438              .u.string_val = vm }
439        };
440
441    abstract_type result_type = abstract_type_int;
442
443    XEN_CALL_("VM.get_memory_static_max");
444    return session->ok;
445}
446
447
448bool
449xen_vm_get_memory_dynamic_max(xen_session *session, int64_t *result, xen_vm vm)
450{
451    abstract_value param_values[] =
452        {
453            { .type = &abstract_type_string,
454              .u.string_val = vm }
455        };
456
457    abstract_type result_type = abstract_type_int;
458
459    XEN_CALL_("VM.get_memory_dynamic_max");
460    return session->ok;
461}
462
463
464bool
465xen_vm_get_memory_dynamic_min(xen_session *session, int64_t *result, xen_vm vm)
466{
467    abstract_value param_values[] =
468        {
469            { .type = &abstract_type_string,
470              .u.string_val = vm }
471        };
472
473    abstract_type result_type = abstract_type_int;
474
475    XEN_CALL_("VM.get_memory_dynamic_min");
476    return session->ok;
477}
478
479
480bool
481xen_vm_get_memory_static_min(xen_session *session, int64_t *result, xen_vm vm)
482{
483    abstract_value param_values[] =
484        {
485            { .type = &abstract_type_string,
486              .u.string_val = vm }
487        };
488
489    abstract_type result_type = abstract_type_int;
490
491    XEN_CALL_("VM.get_memory_static_min");
492    return session->ok;
493}
494
495
496bool
497xen_vm_get_vcpus_params(xen_session *session, xen_string_string_map **result, xen_vm vm)
498{
499    abstract_value param_values[] =
500        {
501            { .type = &abstract_type_string,
502              .u.string_val = vm }
503        };
504
505    abstract_type result_type = abstract_type_string_string_map;
506
507    *result = NULL;
508    XEN_CALL_("VM.get_VCPUs_params");
509    return session->ok;
510}
511
512
513bool
514xen_vm_get_vcpus_max(xen_session *session, int64_t *result, xen_vm vm)
515{
516    abstract_value param_values[] =
517        {
518            { .type = &abstract_type_string,
519              .u.string_val = vm }
520        };
521
522    abstract_type result_type = abstract_type_int;
523
524    XEN_CALL_("VM.get_VCPUs_max");
525    return session->ok;
526}
527
528
529bool
530xen_vm_get_vcpus_at_startup(xen_session *session, int64_t *result, xen_vm vm)
531{
532    abstract_value param_values[] =
533        {
534            { .type = &abstract_type_string,
535              .u.string_val = vm }
536        };
537
538    abstract_type result_type = abstract_type_int;
539
540    XEN_CALL_("VM.get_VCPUs_at_startup");
541    return session->ok;
542}
543
544
545bool
546xen_vm_get_actions_after_shutdown(xen_session *session, enum xen_on_normal_exit *result, xen_vm vm)
547{
548    abstract_value param_values[] =
549        {
550            { .type = &abstract_type_string,
551              .u.string_val = vm }
552        };
553
554    abstract_type result_type = xen_on_normal_exit_abstract_type_;
555    XEN_CALL_("VM.get_actions_after_shutdown");
556    return session->ok;
557}
558
559
560bool
561xen_vm_get_actions_after_reboot(xen_session *session, enum xen_on_normal_exit *result, xen_vm vm)
562{
563    abstract_value param_values[] =
564        {
565            { .type = &abstract_type_string,
566              .u.string_val = vm }
567        };
568
569    abstract_type result_type = xen_on_normal_exit_abstract_type_;
570    XEN_CALL_("VM.get_actions_after_reboot");
571    return session->ok;
572}
573
574
575bool
576xen_vm_get_actions_after_crash(xen_session *session, enum xen_on_crash_behaviour *result, xen_vm vm)
577{
578    abstract_value param_values[] =
579        {
580            { .type = &abstract_type_string,
581              .u.string_val = vm }
582        };
583
584    abstract_type result_type = xen_on_crash_behaviour_abstract_type_;
585    XEN_CALL_("VM.get_actions_after_crash");
586    return session->ok;
587}
588
589
590bool
591xen_vm_get_consoles(xen_session *session, struct xen_console_set **result, xen_vm vm)
592{
593    abstract_value param_values[] =
594        {
595            { .type = &abstract_type_string,
596              .u.string_val = vm }
597        };
598
599    abstract_type result_type = abstract_type_string_set;
600
601    *result = NULL;
602    XEN_CALL_("VM.get_consoles");
603    return session->ok;
604}
605
606
607bool
608xen_vm_get_vifs(xen_session *session, struct xen_vif_set **result, xen_vm vm)
609{
610    abstract_value param_values[] =
611        {
612            { .type = &abstract_type_string,
613              .u.string_val = vm }
614        };
615
616    abstract_type result_type = abstract_type_string_set;
617
618    *result = NULL;
619    XEN_CALL_("VM.get_VIFs");
620    return session->ok;
621}
622
623
624bool
625xen_vm_get_vbds(xen_session *session, struct xen_vbd_set **result, xen_vm vm)
626{
627    abstract_value param_values[] =
628        {
629            { .type = &abstract_type_string,
630              .u.string_val = vm }
631        };
632
633    abstract_type result_type = abstract_type_string_set;
634
635    *result = NULL;
636    XEN_CALL_("VM.get_VBDs");
637    return session->ok;
638}
639
640
641bool
642xen_vm_get_crash_dumps(xen_session *session, struct xen_crashdump_set **result, xen_vm vm)
643{
644    abstract_value param_values[] =
645        {
646            { .type = &abstract_type_string,
647              .u.string_val = vm }
648        };
649
650    abstract_type result_type = abstract_type_string_set;
651
652    *result = NULL;
653    XEN_CALL_("VM.get_crash_dumps");
654    return session->ok;
655}
656
657
658bool
659xen_vm_get_vtpms(xen_session *session, struct xen_vtpm_set **result, xen_vm vm)
660{
661    abstract_value param_values[] =
662        {
663            { .type = &abstract_type_string,
664              .u.string_val = vm }
665        };
666
667    abstract_type result_type = abstract_type_string_set;
668
669    *result = NULL;
670    XEN_CALL_("VM.get_VTPMs");
671    return session->ok;
672}
673
674
675bool
676xen_vm_get_pv_bootloader(xen_session *session, char **result, xen_vm vm)
677{
678    abstract_value param_values[] =
679        {
680            { .type = &abstract_type_string,
681              .u.string_val = vm }
682        };
683
684    abstract_type result_type = abstract_type_string;
685
686    *result = NULL;
687    XEN_CALL_("VM.get_PV_bootloader");
688    return session->ok;
689}
690
691
692bool
693xen_vm_get_pv_kernel(xen_session *session, char **result, xen_vm vm)
694{
695    abstract_value param_values[] =
696        {
697            { .type = &abstract_type_string,
698              .u.string_val = vm }
699        };
700
701    abstract_type result_type = abstract_type_string;
702
703    *result = NULL;
704    XEN_CALL_("VM.get_PV_kernel");
705    return session->ok;
706}
707
708
709bool
710xen_vm_get_pv_ramdisk(xen_session *session, char **result, xen_vm vm)
711{
712    abstract_value param_values[] =
713        {
714            { .type = &abstract_type_string,
715              .u.string_val = vm }
716        };
717
718    abstract_type result_type = abstract_type_string;
719
720    *result = NULL;
721    XEN_CALL_("VM.get_PV_ramdisk");
722    return session->ok;
723}
724
725
726bool
727xen_vm_get_pv_args(xen_session *session, char **result, xen_vm vm)
728{
729    abstract_value param_values[] =
730        {
731            { .type = &abstract_type_string,
732              .u.string_val = vm }
733        };
734
735    abstract_type result_type = abstract_type_string;
736
737    *result = NULL;
738    XEN_CALL_("VM.get_PV_args");
739    return session->ok;
740}
741
742
743bool
744xen_vm_get_pv_bootloader_args(xen_session *session, char **result, xen_vm vm)
745{
746    abstract_value param_values[] =
747        {
748            { .type = &abstract_type_string,
749              .u.string_val = vm }
750        };
751
752    abstract_type result_type = abstract_type_string;
753
754    *result = NULL;
755    XEN_CALL_("VM.get_PV_bootloader_args");
756    return session->ok;
757}
758
759
760bool
761xen_vm_get_hvm_boot_policy(xen_session *session, char **result, xen_vm vm)
762{
763    abstract_value param_values[] =
764        {
765            { .type = &abstract_type_string,
766              .u.string_val = vm }
767        };
768
769    abstract_type result_type = abstract_type_string;
770
771    *result = NULL;
772    XEN_CALL_("VM.get_HVM_boot_policy");
773    return session->ok;
774}
775
776
777bool
778xen_vm_get_hvm_boot_params(xen_session *session, xen_string_string_map **result, xen_vm vm)
779{
780    abstract_value param_values[] =
781        {
782            { .type = &abstract_type_string,
783              .u.string_val = vm }
784        };
785
786    abstract_type result_type = abstract_type_string_string_map;
787
788    *result = NULL;
789    XEN_CALL_("VM.get_HVM_boot_params");
790    return session->ok;
791}
792
793
794bool
795xen_vm_get_platform(xen_session *session, xen_string_string_map **result, xen_vm vm)
796{
797    abstract_value param_values[] =
798        {
799            { .type = &abstract_type_string,
800              .u.string_val = vm }
801        };
802
803    abstract_type result_type = abstract_type_string_string_map;
804
805    *result = NULL;
806    XEN_CALL_("VM.get_platform");
807    return session->ok;
808}
809
810
811bool
812xen_vm_get_pci_bus(xen_session *session, char **result, xen_vm vm)
813{
814    abstract_value param_values[] =
815        {
816            { .type = &abstract_type_string,
817              .u.string_val = vm }
818        };
819
820    abstract_type result_type = abstract_type_string;
821
822    *result = NULL;
823    XEN_CALL_("VM.get_PCI_bus");
824    return session->ok;
825}
826
827
828bool
829xen_vm_get_other_config(xen_session *session, xen_string_string_map **result, xen_vm vm)
830{
831    abstract_value param_values[] =
832        {
833            { .type = &abstract_type_string,
834              .u.string_val = vm }
835        };
836
837    abstract_type result_type = abstract_type_string_string_map;
838
839    *result = NULL;
840    XEN_CALL_("VM.get_other_config");
841    return session->ok;
842}
843
844
845bool
846xen_vm_get_domid(xen_session *session, int64_t *result, xen_vm vm)
847{
848    abstract_value param_values[] =
849        {
850            { .type = &abstract_type_string,
851              .u.string_val = vm }
852        };
853
854    abstract_type result_type = abstract_type_int;
855
856    XEN_CALL_("VM.get_domid");
857    return session->ok;
858}
859
860
861bool
862xen_vm_get_is_control_domain(xen_session *session, bool *result, xen_vm vm)
863{
864    abstract_value param_values[] =
865        {
866            { .type = &abstract_type_string,
867              .u.string_val = vm }
868        };
869
870    abstract_type result_type = abstract_type_bool;
871
872    XEN_CALL_("VM.get_is_control_domain");
873    return session->ok;
874}
875
876
877bool
878xen_vm_get_metrics(xen_session *session, xen_vm_metrics *result, xen_vm vm)
879{
880    abstract_value param_values[] =
881        {
882            { .type = &abstract_type_string,
883              .u.string_val = vm }
884        };
885
886    abstract_type result_type = abstract_type_string;
887
888    *result = NULL;
889    XEN_CALL_("VM.get_metrics");
890    return session->ok;
891}
892
893
894bool
895xen_vm_get_guest_metrics(xen_session *session, xen_vm_guest_metrics *result, xen_vm vm)
896{
897    abstract_value param_values[] =
898        {
899            { .type = &abstract_type_string,
900              .u.string_val = vm }
901        };
902
903    abstract_type result_type = abstract_type_string;
904
905    *result = NULL;
906    XEN_CALL_("VM.get_guest_metrics");
907    return session->ok;
908}
909
910
911bool
912xen_vm_set_name_label(xen_session *session, xen_vm vm, char *label)
913{
914    abstract_value param_values[] =
915        {
916            { .type = &abstract_type_string,
917              .u.string_val = vm },
918            { .type = &abstract_type_string,
919              .u.string_val = label }
920        };
921
922    xen_call_(session, "VM.set_name_label", param_values, 2, NULL, NULL);
923    return session->ok;
924}
925
926
927bool
928xen_vm_set_name_description(xen_session *session, xen_vm vm, char *description)
929{
930    abstract_value param_values[] =
931        {
932            { .type = &abstract_type_string,
933              .u.string_val = vm },
934            { .type = &abstract_type_string,
935              .u.string_val = description }
936        };
937
938    xen_call_(session, "VM.set_name_description", param_values, 2, NULL, NULL);
939    return session->ok;
940}
941
942
943bool
944xen_vm_set_user_version(xen_session *session, xen_vm vm, int64_t user_version)
945{
946    abstract_value param_values[] =
947        {
948            { .type = &abstract_type_string,
949              .u.string_val = vm },
950            { .type = &abstract_type_int,
951              .u.int_val = user_version }
952        };
953
954    xen_call_(session, "VM.set_user_version", param_values, 2, NULL, NULL);
955    return session->ok;
956}
957
958
959bool
960xen_vm_set_is_a_template(xen_session *session, xen_vm vm, bool is_a_template)
961{
962    abstract_value param_values[] =
963        {
964            { .type = &abstract_type_string,
965              .u.string_val = vm },
966            { .type = &abstract_type_bool,
967              .u.bool_val = is_a_template }
968        };
969
970    xen_call_(session, "VM.set_is_a_template", param_values, 2, NULL, NULL);
971    return session->ok;
972}
973
974
975bool
976xen_vm_set_auto_power_on(xen_session *session, xen_vm vm, bool auto_power_on)
977{
978    abstract_value param_values[] =
979        {
980            { .type = &abstract_type_string,
981              .u.string_val = vm },
982            { .type = &abstract_type_bool,
983              .u.bool_val = auto_power_on }
984        };
985
986    xen_call_(session, "VM.set_auto_power_on", param_values, 2, NULL, NULL);
987    return session->ok;
988}
989
990
991bool
992xen_vm_set_memory_static_max(xen_session *session, xen_vm vm, int64_t static_max)
993{
994    abstract_value param_values[] =
995        {
996            { .type = &abstract_type_string,
997              .u.string_val = vm },
998            { .type = &abstract_type_int,
999              .u.int_val = static_max }
1000        };
1001
1002    xen_call_(session, "VM.set_memory_static_max", param_values, 2, NULL, NULL);
1003    return session->ok;
1004}
1005
1006
1007bool
1008xen_vm_set_memory_dynamic_max(xen_session *session, xen_vm vm, int64_t dynamic_max)
1009{
1010    abstract_value param_values[] =
1011        {
1012            { .type = &abstract_type_string,
1013              .u.string_val = vm },
1014            { .type = &abstract_type_int,
1015              .u.int_val = dynamic_max }
1016        };
1017
1018    xen_call_(session, "VM.set_memory_dynamic_max", param_values, 2, NULL, NULL);
1019    return session->ok;
1020}
1021
1022
1023bool
1024xen_vm_set_memory_dynamic_min(xen_session *session, xen_vm vm, int64_t dynamic_min)
1025{
1026    abstract_value param_values[] =
1027        {
1028            { .type = &abstract_type_string,
1029              .u.string_val = vm },
1030            { .type = &abstract_type_int,
1031              .u.int_val = dynamic_min }
1032        };
1033
1034    xen_call_(session, "VM.set_memory_dynamic_min", param_values, 2, NULL, NULL);
1035    return session->ok;
1036}
1037
1038
1039bool
1040xen_vm_set_memory_static_min(xen_session *session, xen_vm vm, int64_t static_min)
1041{
1042    abstract_value param_values[] =
1043        {
1044            { .type = &abstract_type_string,
1045              .u.string_val = vm },
1046            { .type = &abstract_type_int,
1047              .u.int_val = static_min }
1048        };
1049
1050    xen_call_(session, "VM.set_memory_static_min", param_values, 2, NULL, NULL);
1051    return session->ok;
1052}
1053
1054
1055bool
1056xen_vm_set_vcpus_params(xen_session *session, xen_vm vm, xen_string_string_map *params)
1057{
1058    abstract_value param_values[] =
1059        {
1060            { .type = &abstract_type_string,
1061              .u.string_val = vm },
1062            { .type = &abstract_type_string_string_map,
1063              .u.set_val = (arbitrary_set *)params }
1064        };
1065
1066    xen_call_(session, "VM.set_VCPUs_params", param_values, 2, NULL, NULL);
1067    return session->ok;
1068}
1069
1070
1071bool
1072xen_vm_add_to_vcpus_params(xen_session *session, xen_vm vm, char *key, char *value)
1073{
1074    abstract_value param_values[] =
1075        {
1076            { .type = &abstract_type_string,
1077              .u.string_val = vm },
1078            { .type = &abstract_type_string,
1079              .u.string_val = key },
1080            { .type = &abstract_type_string,
1081              .u.string_val = value }
1082        };
1083
1084    xen_call_(session, "VM.add_to_VCPUs_params", param_values, 3, NULL, NULL);
1085    return session->ok;
1086}
1087
1088
1089bool
1090xen_vm_remove_from_vcpus_params(xen_session *session, xen_vm vm, char *key)
1091{
1092    abstract_value param_values[] =
1093        {
1094            { .type = &abstract_type_string,
1095              .u.string_val = vm },
1096            { .type = &abstract_type_string,
1097              .u.string_val = key }
1098        };
1099
1100    xen_call_(session, "VM.remove_from_VCPUs_params", param_values, 2, NULL, NULL);
1101    return session->ok;
1102}
1103
1104
1105bool
1106xen_vm_set_vcpus_max(xen_session *session, xen_vm vm, int64_t max)
1107{
1108    abstract_value param_values[] =
1109        {
1110            { .type = &abstract_type_string,
1111              .u.string_val = vm },
1112            { .type = &abstract_type_int,
1113              .u.int_val = max }
1114        };
1115
1116    xen_call_(session, "VM.set_VCPUs_max", param_values, 2, NULL, NULL);
1117    return session->ok;
1118}
1119
1120
1121bool
1122xen_vm_set_vcpus_at_startup(xen_session *session, xen_vm vm, int64_t at_startup)
1123{
1124    abstract_value param_values[] =
1125        {
1126            { .type = &abstract_type_string,
1127              .u.string_val = vm },
1128            { .type = &abstract_type_int,
1129              .u.int_val = at_startup }
1130        };
1131
1132    xen_call_(session, "VM.set_VCPUs_at_startup", param_values, 2, NULL, NULL);
1133    return session->ok;
1134}
1135
1136
1137bool
1138xen_vm_set_actions_after_shutdown(xen_session *session, xen_vm vm, enum xen_on_normal_exit after_shutdown)
1139{
1140    abstract_value param_values[] =
1141        {
1142            { .type = &abstract_type_string,
1143              .u.string_val = vm },
1144            { .type = &xen_on_normal_exit_abstract_type_,
1145              .u.string_val = xen_on_normal_exit_to_string(after_shutdown) }
1146        };
1147
1148    xen_call_(session, "VM.set_actions_after_shutdown", param_values, 2, NULL, NULL);
1149    return session->ok;
1150}
1151
1152
1153bool
1154xen_vm_set_actions_after_reboot(xen_session *session, xen_vm vm, enum xen_on_normal_exit after_reboot)
1155{
1156    abstract_value param_values[] =
1157        {
1158            { .type = &abstract_type_string,
1159              .u.string_val = vm },
1160            { .type = &xen_on_normal_exit_abstract_type_,
1161              .u.string_val = xen_on_normal_exit_to_string(after_reboot) }
1162        };
1163
1164    xen_call_(session, "VM.set_actions_after_reboot", param_values, 2, NULL, NULL);
1165    return session->ok;
1166}
1167
1168
1169bool
1170xen_vm_set_actions_after_crash(xen_session *session, xen_vm vm, enum xen_on_crash_behaviour after_crash)
1171{
1172    abstract_value param_values[] =
1173        {
1174            { .type = &abstract_type_string,
1175              .u.string_val = vm },
1176            { .type = &xen_on_crash_behaviour_abstract_type_,
1177              .u.string_val = xen_on_crash_behaviour_to_string(after_crash) }
1178        };
1179
1180    xen_call_(session, "VM.set_actions_after_crash", param_values, 2, NULL, NULL);
1181    return session->ok;
1182}
1183
1184
1185bool
1186xen_vm_set_pv_bootloader(xen_session *session, xen_vm vm, char *bootloader)
1187{
1188    abstract_value param_values[] =
1189        {
1190            { .type = &abstract_type_string,
1191              .u.string_val = vm },
1192            { .type = &abstract_type_string,
1193              .u.string_val = bootloader }
1194        };
1195
1196    xen_call_(session, "VM.set_PV_bootloader", param_values, 2, NULL, NULL);
1197    return session->ok;
1198}
1199
1200
1201bool
1202xen_vm_set_pv_kernel(xen_session *session, xen_vm vm, char *kernel)
1203{
1204    abstract_value param_values[] =
1205        {
1206            { .type = &abstract_type_string,
1207              .u.string_val = vm },
1208            { .type = &abstract_type_string,
1209              .u.string_val = kernel }
1210        };
1211
1212    xen_call_(session, "VM.set_PV_kernel", param_values, 2, NULL, NULL);
1213    return session->ok;
1214}
1215
1216
1217bool
1218xen_vm_set_pv_ramdisk(xen_session *session, xen_vm vm, char *ramdisk)
1219{
1220    abstract_value param_values[] =
1221        {
1222            { .type = &abstract_type_string,
1223              .u.string_val = vm },
1224            { .type = &abstract_type_string,
1225              .u.string_val = ramdisk }
1226        };
1227
1228    xen_call_(session, "VM.set_PV_ramdisk", param_values, 2, NULL, NULL);
1229    return session->ok;
1230}
1231
1232
1233bool
1234xen_vm_set_pv_args(xen_session *session, xen_vm vm, char *args)
1235{
1236    abstract_value param_values[] =
1237        {
1238            { .type = &abstract_type_string,
1239              .u.string_val = vm },
1240            { .type = &abstract_type_string,
1241              .u.string_val = args }
1242        };
1243
1244    xen_call_(session, "VM.set_PV_args", param_values, 2, NULL, NULL);
1245    return session->ok;
1246}
1247
1248
1249bool
1250xen_vm_set_pv_bootloader_args(xen_session *session, xen_vm vm, char *bootloader_args)
1251{
1252    abstract_value param_values[] =
1253        {
1254            { .type = &abstract_type_string,
1255              .u.string_val = vm },
1256            { .type = &abstract_type_string,
1257              .u.string_val = bootloader_args }
1258        };
1259
1260    xen_call_(session, "VM.set_PV_bootloader_args", param_values, 2, NULL, NULL);
1261    return session->ok;
1262}
1263
1264
1265bool
1266xen_vm_set_hvm_boot_policy(xen_session *session, xen_vm vm, char *boot_policy)
1267{
1268    abstract_value param_values[] =
1269        {
1270            { .type = &abstract_type_string,
1271              .u.string_val = vm },
1272            { .type = &abstract_type_string,
1273              .u.string_val = boot_policy }
1274        };
1275
1276    xen_call_(session, "VM.set_HVM_boot_policy", param_values, 2, NULL, NULL);
1277    return session->ok;
1278}
1279
1280
1281bool
1282xen_vm_set_hvm_boot_params(xen_session *session, xen_vm vm, xen_string_string_map *boot_params)
1283{
1284    abstract_value param_values[] =
1285        {
1286            { .type = &abstract_type_string,
1287              .u.string_val = vm },
1288            { .type = &abstract_type_string_string_map,
1289              .u.set_val = (arbitrary_set *)boot_params }
1290        };
1291
1292    xen_call_(session, "VM.set_HVM_boot_params", param_values, 2, NULL, NULL);
1293    return session->ok;
1294}
1295
1296
1297bool
1298xen_vm_add_to_hvm_boot_params(xen_session *session, xen_vm vm, char *key, char *value)
1299{
1300    abstract_value param_values[] =
1301        {
1302            { .type = &abstract_type_string,
1303              .u.string_val = vm },
1304            { .type = &abstract_type_string,
1305              .u.string_val = key },
1306            { .type = &abstract_type_string,
1307              .u.string_val = value }
1308        };
1309
1310    xen_call_(session, "VM.add_to_HVM_boot_params", param_values, 3, NULL, NULL);
1311    return session->ok;
1312}
1313
1314
1315bool
1316xen_vm_remove_from_hvm_boot_params(xen_session *session, xen_vm vm, char *key)
1317{
1318    abstract_value param_values[] =
1319        {
1320            { .type = &abstract_type_string,
1321              .u.string_val = vm },
1322            { .type = &abstract_type_string,
1323              .u.string_val = key }
1324        };
1325
1326    xen_call_(session, "VM.remove_from_HVM_boot_params", param_values, 2, NULL, NULL);
1327    return session->ok;
1328}
1329
1330
1331bool
1332xen_vm_set_platform(xen_session *session, xen_vm vm, xen_string_string_map *platform)
1333{
1334    abstract_value param_values[] =
1335        {
1336            { .type = &abstract_type_string,
1337              .u.string_val = vm },
1338            { .type = &abstract_type_string_string_map,
1339              .u.set_val = (arbitrary_set *)platform }
1340        };
1341
1342    xen_call_(session, "VM.set_platform", param_values, 2, NULL, NULL);
1343    return session->ok;
1344}
1345
1346
1347bool
1348xen_vm_add_to_platform(xen_session *session, xen_vm vm, char *key, char *value)
1349{
1350    abstract_value param_values[] =
1351        {
1352            { .type = &abstract_type_string,
1353              .u.string_val = vm },
1354            { .type = &abstract_type_string,
1355              .u.string_val = key },
1356            { .type = &abstract_type_string,
1357              .u.string_val = value }
1358        };
1359
1360    xen_call_(session, "VM.add_to_platform", param_values, 3, NULL, NULL);
1361    return session->ok;
1362}
1363
1364
1365bool
1366xen_vm_remove_from_platform(xen_session *session, xen_vm vm, char *key)
1367{
1368    abstract_value param_values[] =
1369        {
1370            { .type = &abstract_type_string,
1371              .u.string_val = vm },
1372            { .type = &abstract_type_string,
1373              .u.string_val = key }
1374        };
1375
1376    xen_call_(session, "VM.remove_from_platform", param_values, 2, NULL, NULL);
1377    return session->ok;
1378}
1379
1380
1381bool
1382xen_vm_set_pci_bus(xen_session *session, xen_vm vm, char *pci_bus)
1383{
1384    abstract_value param_values[] =
1385        {
1386            { .type = &abstract_type_string,
1387              .u.string_val = vm },
1388            { .type = &abstract_type_string,
1389              .u.string_val = pci_bus }
1390        };
1391
1392    xen_call_(session, "VM.set_PCI_bus", param_values, 2, NULL, NULL);
1393    return session->ok;
1394}
1395
1396
1397bool
1398xen_vm_set_other_config(xen_session *session, xen_vm vm, xen_string_string_map *other_config)
1399{
1400    abstract_value param_values[] =
1401        {
1402            { .type = &abstract_type_string,
1403              .u.string_val = vm },
1404            { .type = &abstract_type_string_string_map,
1405              .u.set_val = (arbitrary_set *)other_config }
1406        };
1407
1408    xen_call_(session, "VM.set_other_config", param_values, 2, NULL, NULL);
1409    return session->ok;
1410}
1411
1412
1413bool
1414xen_vm_add_to_other_config(xen_session *session, xen_vm vm, char *key, char *value)
1415{
1416    abstract_value param_values[] =
1417        {
1418            { .type = &abstract_type_string,
1419              .u.string_val = vm },
1420            { .type = &abstract_type_string,
1421              .u.string_val = key },
1422            { .type = &abstract_type_string,
1423              .u.string_val = value }
1424        };
1425
1426    xen_call_(session, "VM.add_to_other_config", param_values, 3, NULL, NULL);
1427    return session->ok;
1428}
1429
1430
1431bool
1432xen_vm_remove_from_other_config(xen_session *session, xen_vm vm, char *key)
1433{
1434    abstract_value param_values[] =
1435        {
1436            { .type = &abstract_type_string,
1437              .u.string_val = vm },
1438            { .type = &abstract_type_string,
1439              .u.string_val = key }
1440        };
1441
1442    xen_call_(session, "VM.remove_from_other_config", param_values, 2, NULL, NULL);
1443    return session->ok;
1444}
1445
1446
1447bool
1448xen_vm_clone(xen_session *session, xen_vm *result, xen_vm vm, char *new_name)
1449{
1450    abstract_value param_values[] =
1451        {
1452            { .type = &abstract_type_string,
1453              .u.string_val = vm },
1454            { .type = &abstract_type_string,
1455              .u.string_val = new_name }
1456        };
1457
1458    abstract_type result_type = abstract_type_string;
1459
1460    *result = NULL;
1461    XEN_CALL_("VM.clone");
1462    return session->ok;
1463}
1464
1465
1466bool
1467xen_vm_start(xen_session *session, xen_vm vm, bool start_paused)
1468{
1469    abstract_value param_values[] =
1470        {
1471            { .type = &abstract_type_string,
1472              .u.string_val = vm },
1473            { .type = &abstract_type_bool,
1474              .u.bool_val = start_paused }
1475        };
1476
1477    xen_call_(session, "VM.start", param_values, 2, NULL, NULL);
1478    return session->ok;
1479}
1480
1481
1482bool
1483xen_vm_pause(xen_session *session, xen_vm vm)
1484{
1485    abstract_value param_values[] =
1486        {
1487            { .type = &abstract_type_string,
1488              .u.string_val = vm }
1489        };
1490
1491    xen_call_(session, "VM.pause", param_values, 1, NULL, NULL);
1492    return session->ok;
1493}
1494
1495
1496bool
1497xen_vm_unpause(xen_session *session, xen_vm vm)
1498{
1499    abstract_value param_values[] =
1500        {
1501            { .type = &abstract_type_string,
1502              .u.string_val = vm }
1503        };
1504
1505    xen_call_(session, "VM.unpause", param_values, 1, NULL, NULL);
1506    return session->ok;
1507}
1508
1509
1510bool
1511xen_vm_clean_shutdown(xen_session *session, xen_vm vm)
1512{
1513    abstract_value param_values[] =
1514        {
1515            { .type = &abstract_type_string,
1516              .u.string_val = vm }
1517        };
1518
1519    xen_call_(session, "VM.clean_shutdown", param_values, 1, NULL, NULL);
1520    return session->ok;
1521}
1522
1523
1524bool
1525xen_vm_clean_reboot(xen_session *session, xen_vm vm)
1526{
1527    abstract_value param_values[] =
1528        {
1529            { .type = &abstract_type_string,
1530              .u.string_val = vm }
1531        };
1532
1533    xen_call_(session, "VM.clean_reboot", param_values, 1, NULL, NULL);
1534    return session->ok;
1535}
1536
1537
1538bool
1539xen_vm_hard_shutdown(xen_session *session, xen_vm vm)
1540{
1541    abstract_value param_values[] =
1542        {
1543            { .type = &abstract_type_string,
1544              .u.string_val = vm }
1545        };
1546
1547    xen_call_(session, "VM.hard_shutdown", param_values, 1, NULL, NULL);
1548    return session->ok;
1549}
1550
1551
1552bool
1553xen_vm_hard_reboot(xen_session *session, xen_vm vm)
1554{
1555    abstract_value param_values[] =
1556        {
1557            { .type = &abstract_type_string,
1558              .u.string_val = vm }
1559        };
1560
1561    xen_call_(session, "VM.hard_reboot", param_values, 1, NULL, NULL);
1562    return session->ok;
1563}
1564
1565
1566bool
1567xen_vm_suspend(xen_session *session, xen_vm vm)
1568{
1569    abstract_value param_values[] =
1570        {
1571            { .type = &abstract_type_string,
1572              .u.string_val = vm }
1573        };
1574
1575    xen_call_(session, "VM.suspend", param_values, 1, NULL, NULL);
1576    return session->ok;
1577}
1578
1579
1580bool
1581xen_vm_resume(xen_session *session, xen_vm vm, bool start_paused)
1582{
1583    abstract_value param_values[] =
1584        {
1585            { .type = &abstract_type_string,
1586              .u.string_val = vm },
1587            { .type = &abstract_type_bool,
1588              .u.bool_val = start_paused }
1589        };
1590
1591    xen_call_(session, "VM.resume", param_values, 2, NULL, NULL);
1592    return session->ok;
1593}
1594
1595
1596bool
1597xen_vm_set_vcpus_number_live(xen_session *session, xen_vm self, int64_t nvcpu)
1598{
1599    abstract_value param_values[] =
1600        {
1601            { .type = &abstract_type_string,
1602              .u.string_val = self },
1603            { .type = &abstract_type_int,
1604              .u.int_val = nvcpu }
1605        };
1606
1607    xen_call_(session, "VM.set_VCPUs_number_live", param_values, 2, NULL, NULL);
1608    return session->ok;
1609}
1610
1611
1612bool
1613xen_vm_add_to_vcpus_params_live(xen_session *session, xen_vm self, char *key, char *value)
1614{
1615    abstract_value param_values[] =
1616        {
1617            { .type = &abstract_type_string,
1618              .u.string_val = self },
1619            { .type = &abstract_type_string,
1620              .u.string_val = key },
1621            { .type = &abstract_type_string,
1622              .u.string_val = value }
1623        };
1624
1625    xen_call_(session, "VM.add_to_VCPUs_params_live", param_values, 3, NULL, NULL);
1626    return session->ok;
1627}
1628
1629
1630bool
1631xen_vm_set_memory_dynamic_max_live(xen_session *session, xen_vm self, int64_t max)
1632{
1633    abstract_value param_values[] =
1634        {
1635            { .type = &abstract_type_string,
1636              .u.string_val = self },
1637            { .type = &abstract_type_int,
1638              .u.int_val = max }
1639        };
1640
1641    xen_call_(session, "VM.set_memory_dynamic_max_live", param_values, 2, NULL, NULL);
1642    return session->ok;
1643}
1644
1645
1646bool
1647xen_vm_set_memory_dynamic_min_live(xen_session *session, xen_vm self, int64_t min)
1648{
1649    abstract_value param_values[] =
1650        {
1651            { .type = &abstract_type_string,
1652              .u.string_val = self },
1653            { .type = &abstract_type_int,
1654              .u.int_val = min }
1655        };
1656
1657    xen_call_(session, "VM.set_memory_dynamic_min_live", param_values, 2, NULL, NULL);
1658    return session->ok;
1659}
1660
1661
1662bool
1663xen_vm_send_sysrq(xen_session *session, xen_vm vm, char *key)
1664{
1665    abstract_value param_values[] =
1666        {
1667            { .type = &abstract_type_string,
1668              .u.string_val = vm },
1669            { .type = &abstract_type_string,
1670              .u.string_val = key }
1671        };
1672
1673    xen_call_(session, "VM.send_sysrq", param_values, 2, NULL, NULL);
1674    return session->ok;
1675}
1676
1677
1678bool
1679xen_vm_send_trigger(xen_session *session, xen_vm vm, char *trigger)
1680{
1681    abstract_value param_values[] =
1682        {
1683            { .type = &abstract_type_string,
1684              .u.string_val = vm },
1685            { .type = &abstract_type_string,
1686              .u.string_val = trigger }
1687        };
1688
1689    xen_call_(session, "VM.send_trigger", param_values, 2, NULL, NULL);
1690    return session->ok;
1691}
1692
1693
1694bool
1695xen_vm_migrate(xen_session *session, xen_vm vm, char *dest, bool live, xen_string_string_map *options)
1696{
1697    abstract_value param_values[] =
1698        {
1699            { .type = &abstract_type_string,
1700              .u.string_val = vm },
1701            { .type = &abstract_type_string,
1702              .u.string_val = dest },
1703            { .type = &abstract_type_bool,
1704              .u.bool_val = live },
1705            { .type = &abstract_type_string_string_map,
1706              .u.set_val = (arbitrary_set *)options }
1707        };
1708
1709    xen_call_(session, "VM.migrate", param_values, 4, NULL, NULL);
1710    return session->ok;
1711}
1712
1713
1714bool
1715xen_vm_get_all(xen_session *session, struct xen_vm_set **result)
1716{
1717
1718    abstract_type result_type = abstract_type_string_set;
1719
1720    *result = NULL;
1721    xen_call_(session, "VM.get_all", NULL, 0, &result_type, result);
1722    return session->ok;
1723}
1724
1725
1726bool
1727xen_vm_get_uuid(xen_session *session, char **result, xen_vm vm)
1728{
1729    abstract_value param_values[] =
1730        {
1731            { .type = &abstract_type_string,
1732              .u.string_val = vm }
1733        };
1734
1735    abstract_type result_type = abstract_type_string;
1736
1737    *result = NULL;
1738    XEN_CALL_("VM.get_uuid");
1739    return session->ok;
1740}
Note: See TracBrowser for help on using the repository browser.