2
* xs_internal.c: access to Xen Store
4
* Copyright (C) 2006, 2009 Red Hat, Inc.
6
* See COPYING.LIB for the License of this software
8
* Daniel Veillard <veillard@redhat.com>
19
#include <sys/ioctl.h>
23
#include <xen/dom0_ops.h>
24
#include <xen/version.h>
29
#include "virterror_internal.h"
30
#include "datatypes.h"
36
#include "xen_unified.h"
37
#include "xs_internal.h"
38
#include "xen_internal.h"
40
#define VIR_FROM_THIS VIR_FROM_XEN
43
static char *xenStoreDomainGetOSType(virDomainPtr domain);
44
static void xenStoreWatchEvent(int watch, int fd, int events, void *data);
45
static void xenStoreWatchListFree(xenStoreWatchListPtr list);
47
struct xenUnifiedDriver xenStoreDriver = {
48
xenStoreOpen, /* open */
49
xenStoreClose, /* close */
52
NULL, /* nodeGetInfo */
53
NULL, /* getCapabilities */
54
xenStoreListDomains, /* listDomains */
55
NULL, /* numOfDomains */
56
NULL, /* domainCreateXML */
57
NULL, /* domainSuspend */
58
NULL, /* domainResume */
59
xenStoreDomainShutdown, /* domainShutdown */
60
xenStoreDomainReboot, /* domainReboot */
61
NULL, /* domainDestroy */
62
xenStoreDomainGetOSType, /* domainGetOSType */
63
xenStoreDomainGetMaxMemory, /* domainGetMaxMemory */
64
NULL, /* domainSetMaxMemory */
65
xenStoreDomainSetMemory, /* domainSetMemory */
66
xenStoreGetDomainInfo, /* domainGetInfo */
67
NULL, /* domainSave */
68
NULL, /* domainRestore */
69
NULL, /* domainCoreDump */
70
NULL, /* domainSetVcpus */
71
NULL, /* domainPinVcpu */
72
NULL, /* domainGetVcpus */
73
NULL, /* domainGetMaxVcpus */
74
NULL, /* listDefinedDomains */
75
NULL, /* numOfDefinedDomains */
76
NULL, /* domainCreate */
77
NULL, /* domainDefineXML */
78
NULL, /* domainUndefine */
79
NULL, /* domainAttachDevice */
80
NULL, /* domainDetachDevice */
81
NULL, /* domainGetAutostart */
82
NULL, /* domainSetAutostart */
83
NULL, /* domainGetSchedulerType */
84
NULL, /* domainGetSchedulerParameters */
85
NULL, /* domainSetSchedulerParameters */
90
#define virXenStoreError(conn, code, fmt...) \
91
virReportErrorHelper(NULL, VIR_FROM_XENSTORE, code, __FILE__, \
92
__FUNCTION__, __LINE__, fmt)
94
/************************************************************************
96
* Helper internal APIs *
98
************************************************************************/
101
* virConnectDoStoreList:
102
* @conn: pointer to the hypervisor connection
103
* @path: the absolute path of the directory in the store to list
104
* @nb: OUT pointer to the number of items found
106
* Internal API querying the Xenstore for a list
108
* Returns a string which must be freed by the caller or NULL in case of error
111
virConnectDoStoreList(virConnectPtr conn, const char *path,
114
xenUnifiedPrivatePtr priv;
119
priv = (xenUnifiedPrivatePtr) conn->privateData;
120
if (priv->xshandle == NULL || path == NULL || nb == NULL)
123
return xs_directory (priv->xshandle, 0, path, nb);
128
* virDomainDoStoreQuery:
129
* @conn: pointer to the hypervisor connection
130
* @domid: id of the domain
131
* @path: the relative path of the data in the store to retrieve
133
* Internal API querying the Xenstore for a string value.
135
* Returns a string which must be freed by the caller or NULL in case of error
138
virDomainDoStoreQuery(virConnectPtr conn, int domid, const char *path)
141
unsigned int len = 0;
142
xenUnifiedPrivatePtr priv;
147
priv = (xenUnifiedPrivatePtr) conn->privateData;
148
if (priv->xshandle == NULL)
151
snprintf(s, 255, "/local/domain/%d/%s", domid, path);
154
return xs_read(priv->xshandle, 0, &s[0], &len);
159
* virDomainDoStoreWrite:
160
* @domain: a domain object
161
* @path: the relative path of the data in the store to retrieve
163
* Internal API setting up a string value in the Xenstore
164
* Requires write access to the XenStore
166
* Returns 0 in case of success, -1 in case of failure
169
virDomainDoStoreWrite(virDomainPtr domain, const char *path,
173
xenUnifiedPrivatePtr priv;
176
if (!VIR_IS_CONNECTED_DOMAIN(domain))
179
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
180
if (priv->xshandle == NULL)
182
if (domain->conn->flags & VIR_CONNECT_RO)
185
snprintf(s, 255, "/local/domain/%d/%s", domain->id, path);
188
if (xs_write(priv->xshandle, 0, &s[0], value, strlen(value)))
196
* @domain: a domain object
198
* Internal API extracting a xenstore vm path.
200
* Returns the new string or NULL in case of error
203
virDomainGetVM(virDomainPtr domain)
208
xenUnifiedPrivatePtr priv;
210
if (!VIR_IS_CONNECTED_DOMAIN(domain))
213
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
214
if (priv->xshandle == NULL)
217
snprintf(query, 199, "/local/domain/%d/vm", virDomainGetID(domain));
220
vm = xs_read(priv->xshandle, 0, &query[0], &len);
226
* virDomainGetVMInfo:
227
* @domain: a domain object
228
* @vm: the xenstore vm path
229
* @name: the value's path
231
* Internal API extracting one information the device used
232
* by the domain from xensttore
234
* Returns the new string or NULL in case of error
237
virDomainGetVMInfo(virDomainPtr domain, const char *vm, const char *name)
241
unsigned int len = 0;
242
xenUnifiedPrivatePtr priv;
244
if (!VIR_IS_CONNECTED_DOMAIN(domain))
247
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
248
if (priv->xshandle == NULL)
251
snprintf(s, 255, "%s/%s", vm, name);
254
ret = xs_read(priv->xshandle, 0, &s[0], &len);
261
/************************************************************************
263
* Canonical internal APIs *
265
************************************************************************/
268
* @conn: pointer to the connection block
269
* @name: URL for the target, NULL for local
270
* @flags: combination of virDrvOpenFlag(s)
272
* Connects to the Xen hypervisor.
274
* Returns 0 or -1 in case of error.
277
xenStoreOpen(virConnectPtr conn,
278
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
279
int flags ATTRIBUTE_UNUSED)
281
xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData;
284
priv->xshandle = xs_daemon_open_readonly();
286
if (flags & VIR_CONNECT_RO)
287
priv->xshandle = xs_daemon_open_readonly();
289
priv->xshandle = xs_daemon_open();
292
if (priv->xshandle == NULL) {
294
* not being able to connect via the socket as an unprivileged
295
* user is rather normal, this should fallback to the proxy (or
298
if (xenHavePrivilege()) {
299
virXenStoreError(NULL, VIR_ERR_NO_XEN,
300
"%s", _("failed to connect to Xen Store"));
306
/* Init activeDomainList */
307
if (VIR_ALLOC(priv->activeDomainList) < 0) {
308
virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR,
309
"%s", _("failed to allocate activeDomainList"));
313
/* Init watch list before filling in domInfoList,
314
so we can know if it is the first time through
315
when the callback fires */
316
if ( VIR_ALLOC(priv->xsWatchList) < 0 ) {
317
virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR,
318
"%s", _("failed to allocate xsWatchList"));
322
/* This will get called once at start */
323
if ( xenStoreAddWatch(conn, "@releaseDomain",
324
"releaseDomain", xenStoreDomainReleased, priv) < 0 )
326
virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR,
327
"%s", _("adding watch @releaseDomain"));
331
/* The initial call of this will fill domInfoList */
332
if( xenStoreAddWatch(conn, "@introduceDomain",
333
"introduceDomain", xenStoreDomainIntroduced, priv) < 0 )
335
virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR,
336
"%s", _("adding watch @introduceDomain"));
340
/* Add an event handle */
341
if ((priv->xsWatch = virEventAddHandle(xs_fileno(priv->xshandle),
342
VIR_EVENT_HANDLE_READABLE,
346
DEBUG0("Failed to add event handle, disabling events\n");
354
* @conn: pointer to the connection block
356
* Close the connection to the Xen hypervisor.
358
* Returns 0 in case of success or -1 in case of error.
361
xenStoreClose(virConnectPtr conn)
363
xenUnifiedPrivatePtr priv;
366
virXenStoreError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
370
priv = (xenUnifiedPrivatePtr) conn->privateData;
373
if (xenStoreRemoveWatch(conn, "@introduceDomain", "introduceDomain") < 0) {
374
DEBUG0("Warning, could not remove @introduceDomain watch");
378
if (xenStoreRemoveWatch(conn, "@releaseDomain", "releaseDomain") < 0) {
379
DEBUG0("Warning, could not remove @releaseDomain watch");
383
xenStoreWatchListFree(priv->xsWatchList);
384
priv->xsWatchList = NULL;
385
xenUnifiedDomainInfoListFree(priv->activeDomainList);
386
priv->activeDomainList = NULL;
388
if (priv->xshandle == NULL)
391
if (priv->xsWatch != -1)
392
virEventRemoveHandle(priv->xsWatch);
393
xs_daemon_close(priv->xshandle);
394
priv->xshandle = NULL;
401
* xenStoreGetDomainInfo:
402
* @domain: pointer to the domain block
403
* @info: the place where information should be stored
405
* Do an hypervisor call to get the related set of domain information.
407
* Returns 0 in case of success, -1 in case of error.
410
xenStoreGetDomainInfo(virDomainPtr domain, virDomainInfoPtr info)
413
unsigned int nb_vcpus;
415
xenUnifiedPrivatePtr priv;
417
if (!VIR_IS_CONNECTED_DOMAIN(domain))
420
if ((domain == NULL) || (domain->conn == NULL) || (info == NULL)) {
421
virXenStoreError(domain ? domain->conn : NULL, VIR_ERR_INVALID_ARG,
426
priv = (xenUnifiedPrivatePtr) domain->conn->privateData;
427
if (priv->xshandle == NULL)
430
if (domain->id == -1)
433
tmp = virDomainDoStoreQuery(domain->conn, domain->id, "running");
436
info->state = VIR_DOMAIN_RUNNING;
439
info->state = VIR_DOMAIN_NOSTATE;
441
tmp = virDomainDoStoreQuery(domain->conn, domain->id, "memory/target");
443
info->memory = atol(tmp);
444
info->maxMem = atol(tmp);
451
/* doesn't seems to work */
452
tmp = virDomainDoStoreQuery(domain->conn, domain->id, "cpu_time");
454
info->cpuTime = atol(tmp);
460
snprintf(request, 199, "/local/domain/%d/cpu", domain->id);
462
tmp2 = virConnectDoStoreList(domain->conn, request, &nb_vcpus);
464
info->nrVirtCpu = nb_vcpus;
471
* xenStoreDomainSetMemory:
472
* @domain: pointer to the domain block
473
* @memory: the max memory size in kilobytes.
475
* Change the maximum amount of memory allowed in the xen store
477
* Returns 0 in case of success, -1 in case of error.
480
xenStoreDomainSetMemory(virDomainPtr domain, unsigned long memory)
485
if ((domain == NULL) || (domain->conn == NULL) ||
486
(memory < 1024 * MIN_XEN_GUEST_SIZE)) {
487
virXenStoreError(domain ? domain->conn : NULL, VIR_ERR_INVALID_ARG,
491
if (domain->id == -1)
493
if ((domain->id == 0) && (memory < (2 * MIN_XEN_GUEST_SIZE * 1024)))
495
snprintf(value, 19, "%lu", memory);
497
ret = virDomainDoStoreWrite(domain, "memory/target", &value[0]);
504
* xenStoreDomainGetMaxMemory:
505
* @domain: pointer to the domain block
507
* Ask the xenstore for the maximum memory allowed for a domain
509
* Returns the memory size in kilobytes or 0 in case of error.
512
xenStoreDomainGetMaxMemory(virDomainPtr domain)
515
unsigned long ret = 0;
516
xenUnifiedPrivatePtr priv;
518
if (!VIR_IS_CONNECTED_DOMAIN(domain))
520
if (domain->id == -1)
523
priv = domain->conn->privateData;
524
xenUnifiedLock(priv);
525
tmp = virDomainDoStoreQuery(domain->conn, domain->id, "memory/target");
527
ret = (unsigned long) atol(tmp);
530
xenUnifiedUnlock(priv);
535
* xenStoreNumOfDomains:
536
* @conn: pointer to the hypervisor connection
538
* Provides the number of active domains.
540
* Returns the number of domain found or -1 in case of error
543
xenStoreNumOfDomains(virConnectPtr conn)
548
xenUnifiedPrivatePtr priv;
551
virXenStoreError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
555
priv = (xenUnifiedPrivatePtr) conn->privateData;
556
if (priv->xshandle == NULL) {
557
virXenStoreError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
560
idlist = xs_directory(priv->xshandle, 0, "/local/domain", &num);
569
* xenStoreDoListDomains:
570
* @conn: pointer to the hypervisor connection
571
* @ids: array to collect the list of IDs of active domains
572
* @maxids: size of @ids
574
* Internal API: collect the list of active domains, and store
575
* their ID in @maxids. The driver lock must be held.
577
* Returns the number of domain found or -1 in case of error
580
xenStoreDoListDomains(xenUnifiedPrivatePtr priv, int *ids, int maxids)
582
char **idlist = NULL, *endptr;
587
if (priv->xshandle == NULL)
590
idlist = xs_directory (priv->xshandle, 0, "/local/domain", &num);
594
for (ret = 0, i = 0; (i < num) && (ret < maxids); i++) {
595
id = strtol(idlist[i], &endptr, 10);
596
if ((endptr == idlist[i]) || (*endptr != 0))
598
ids[ret++] = (int) id;
607
* xenStoreListDomains:
608
* @conn: pointer to the hypervisor connection
609
* @ids: array to collect the list of IDs of active domains
610
* @maxids: size of @ids
612
* Collect the list of active domains, and store their ID in @maxids
614
* Returns the number of domain found or -1 in case of error
617
xenStoreListDomains(virConnectPtr conn, int *ids, int maxids)
619
xenUnifiedPrivatePtr priv;
622
if ((conn == NULL) || (ids == NULL)) {
623
virXenStoreError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
627
priv = (xenUnifiedPrivatePtr) conn->privateData;
629
xenUnifiedLock(priv);
630
ret = xenStoreDoListDomains(priv, ids, maxids);
631
xenUnifiedUnlock(priv);
637
* xenStoreLookupByName:
638
* @conn: A xend instance
639
* @name: The name of the domain
641
* Try to lookup a domain on the Xen Store based on its name.
643
* Returns a new domain object or NULL in case of failure
646
xenStoreLookupByName(virConnectPtr conn, const char *name)
648
virDomainPtr ret = NULL;
649
unsigned int num, i, len;
651
char **idlist = NULL, *endptr;
652
char prop[200], *tmp;
654
struct xend_domain *xenddomain = NULL;
655
xenUnifiedPrivatePtr priv;
657
if ((conn == NULL) || (name == NULL)) {
658
virXenStoreError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
662
priv = (xenUnifiedPrivatePtr) conn->privateData;
663
if (priv->xshandle == NULL)
666
idlist = xs_directory(priv->xshandle, 0, "/local/domain", &num);
670
for (i = 0; i < num; i++) {
671
id = strtol(idlist[i], &endptr, 10);
672
if ((endptr == idlist[i]) || (*endptr != 0)) {
676
if (virConnectCheckStoreID(conn, (int) id) < 0)
679
snprintf(prop, 199, "/local/domain/%s/name", idlist[i]);
681
tmp = xs_read(priv->xshandle, 0, prop, &len);
683
found = STREQ (name, tmp);
692
ret = virGetDomain(conn, name, NULL);
706
* xenStoreDomainShutdown:
707
* @domain: pointer to the Domain block
709
* Shutdown the domain, the OS is requested to properly shutdown
710
* and the domain may ignore it. It will return immediately
711
* after queuing the request.
713
* Returns 0 in case of success, -1 in case of error.
716
xenStoreDomainShutdown(virDomainPtr domain)
719
xenUnifiedPrivatePtr priv;
721
if ((domain == NULL) || (domain->conn == NULL)) {
722
virXenStoreError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
726
if (domain->id == -1 || domain->id == 0)
729
* this is very hackish, the domU kernel probes for a special
730
* node in the xenstore and launch the shutdown command if found.
732
priv = domain->conn->privateData;
733
xenUnifiedLock(priv);
734
ret = virDomainDoStoreWrite(domain, "control/shutdown", "poweroff");
735
xenUnifiedUnlock(priv);
740
* xenStoreDomainReboot:
741
* @domain: pointer to the Domain block
742
* @flags: extra flags for the reboot operation, not used yet
744
* Reboot the domain, the OS is requested to properly shutdown
745
* and reboot but the domain may ignore it. It will return immediately
746
* after queuing the request.
748
* Returns 0 in case of success, -1 in case of error.
751
xenStoreDomainReboot(virDomainPtr domain, unsigned int flags ATTRIBUTE_UNUSED)
754
xenUnifiedPrivatePtr priv;
756
if ((domain == NULL) || (domain->conn == NULL)) {
757
virXenStoreError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
761
if (domain->id == -1 || domain->id == 0)
764
* this is very hackish, the domU kernel probes for a special
765
* node in the xenstore and launch the shutdown command if found.
767
priv = domain->conn->privateData;
768
xenUnifiedLock(priv);
769
ret = virDomainDoStoreWrite(domain, "control/shutdown", "reboot");
770
xenUnifiedUnlock(priv);
775
* xenStoreDomainGetOSType:
776
* @domain: a domain object
778
* Get the type of domain operation system.
780
* Returns the new string or NULL in case of error, the string must be
781
* freed by the caller.
784
xenStoreDomainGetOSType(virDomainPtr domain) {
785
char *vm, *str = NULL;
787
if ((domain == NULL) || (domain->conn == NULL)) {
788
virXenStoreError((domain ? domain->conn : NULL), VIR_ERR_INVALID_ARG,
793
vm = virDomainGetVM(domain);
795
xenUnifiedPrivatePtr priv = domain->conn->privateData;
796
xenUnifiedLock(priv);
797
str = virDomainGetVMInfo(domain, vm, "image/ostype");
798
xenUnifiedUnlock(priv);
807
* xenStoreDomainGetVNCPort:
808
* @conn: the hypervisor connection
809
* @domid: id of the domain
811
* Return the port number on which the domain is listening for VNC
814
* The caller must hold the lock on the privateData
815
* associated with the 'conn' parameter.
817
* Returns the port number, -1 in case of error
819
int xenStoreDomainGetVNCPort(virConnectPtr conn, int domid) {
823
tmp = virDomainDoStoreQuery(conn, domid, "console/vnc-port");
826
ret = strtol(tmp, &end, 10);
827
if (ret == 0 && end == tmp)
835
* xenStoreDomainGetConsolePath:
836
* @conn: the hypervisor connection
837
* @domid: id of the domain
839
* Return the path to the psuedo TTY on which the guest domain's
840
* serial console is attached.
842
* Returns the path to the serial console. It is the callers
843
* responsibilty to free() the return string. Returns NULL
846
* The caller must hold the lock on the privateData
847
* associated with the 'conn' parameter.
849
char * xenStoreDomainGetConsolePath(virConnectPtr conn, int domid) {
850
return virDomainDoStoreQuery(conn, domid, "console/tty");
855
* xenStoreDomainGetOSTypeID:
856
* @conn: pointer to the connection.
859
* Get the type of domain operation system.
861
* The caller must hold the lock on the privateData
862
* associated with the 'conn' parameter.
864
* Returns the new string or NULL in case of error, the string must be
865
* freed by the caller.
868
xenStoreDomainGetOSTypeID(virConnectPtr conn, int id) {
869
char *vm, *str = NULL;
872
xenUnifiedPrivatePtr priv;
877
priv = (xenUnifiedPrivatePtr) conn->privateData;
878
if (priv->xshandle == NULL)
881
snprintf(query, 199, "/local/domain/%d/vm", id);
884
vm = xs_read(priv->xshandle, 0, &query[0], &len);
887
snprintf(query, 199, "%s/image/ostype", vm);
888
str = xs_read(priv->xshandle, 0, &query[0], &len);
892
str = strdup("linux");
900
* xenStoreDomainGetNetworkID:
901
* @conn: pointer to the connection.
903
* @mac: the mac address
905
* Get the reference (i.e. the string number) for the device on that domain
906
* which uses the given mac address
908
* The caller must hold the lock on the privateData
909
* associated with the 'conn' parameter.
911
* Returns the new string or NULL in case of error, the string must be
912
* freed by the caller.
915
xenStoreDomainGetNetworkID(virConnectPtr conn, int id, const char *mac) {
916
char dir[80], path[128], **list = NULL, *val = NULL;
917
unsigned int len, i, num;
919
xenUnifiedPrivatePtr priv;
924
priv = (xenUnifiedPrivatePtr) conn->privateData;
925
if (priv->xshandle == NULL)
930
snprintf(dir, sizeof(dir), "/local/domain/0/backend/vif/%d", id);
931
list = xs_directory(priv->xshandle, 0, dir, &num);
934
for (i = 0; i < num; i++) {
935
snprintf(path, sizeof(path), "%s/%s/%s", dir, list[i], "mac");
936
if ((val = xs_read(priv->xshandle, 0, path, &len)) == NULL)
939
bool match = (virMacAddrCompare(val, mac) == 0);
944
ret = strdup(list[i]);
954
* xenStoreDomainGetDiskID:
955
* @conn: pointer to the connection.
957
* @dev: the virtual block device name
959
* Get the reference (i.e. the string number) for the device on that domain
960
* which uses the given virtual block device name
962
* The caller must hold the lock on the privateData
963
* associated with the 'conn' parameter.
965
* Returns the new string or NULL in case of error, the string must be
966
* freed by the caller.
969
xenStoreDomainGetDiskID(virConnectPtr conn, int id, const char *dev) {
970
char dir[80], path[128], **list = NULL, *val = NULL;
971
unsigned int devlen, len, i, num;
973
xenUnifiedPrivatePtr priv;
978
priv = (xenUnifiedPrivatePtr) conn->privateData;
979
if (priv->xshandle == NULL)
983
devlen = strlen(dev);
987
snprintf(dir, sizeof(dir), "/local/domain/0/backend/vbd/%d", id);
988
list = xs_directory(priv->xshandle, 0, dir, &num);
990
for (i = 0; i < num; i++) {
991
snprintf(path, sizeof(path), "%s/%s/%s", dir, list[i], "dev");
992
val = xs_read(priv->xshandle, 0, path, &len);
995
if ((devlen != len) || memcmp(val, dev, len)) {
998
ret = strdup(list[i]);
1006
snprintf(dir, sizeof(dir), "/local/domain/0/backend/tap/%d", id);
1007
list = xs_directory(priv->xshandle, 0, dir, &num);
1009
for (i = 0; i < num; i++) {
1010
snprintf(path, sizeof(path), "%s/%s/%s", dir, list[i], "dev");
1011
val = xs_read(priv->xshandle, 0, path, &len);
1014
if ((devlen != len) || memcmp(val, dev, len)) {
1017
ret = strdup(list[i]);
1029
* The caller must hold the lock on the privateData
1030
* associated with the 'conn' parameter.
1032
char *xenStoreDomainGetName(virConnectPtr conn,
1035
xenUnifiedPrivatePtr priv;
1038
priv = (xenUnifiedPrivatePtr) conn->privateData;
1039
if (priv->xshandle == NULL)
1042
snprintf(prop, 199, "/local/domain/%d/name", id);
1044
return xs_read(priv->xshandle, 0, prop, &len);
1049
* The caller must hold the lock on the privateData
1050
* associated with the 'conn' parameter.
1052
int xenStoreDomainGetUUID(virConnectPtr conn,
1054
unsigned char *uuid) {
1056
xenUnifiedPrivatePtr priv;
1061
priv = (xenUnifiedPrivatePtr) conn->privateData;
1062
if (priv->xshandle == NULL)
1065
snprintf(prop, 199, "/local/domain/%d/vm", id);
1067
// This will return something like
1068
// /vm/00000000-0000-0000-0000-000000000000
1069
uuidstr = xs_read(priv->xshandle, 0, prop, &len);
1072
ret = virUUIDParse(uuidstr + 4, uuid);
1080
xenStoreWatchListFree(xenStoreWatchListPtr list)
1083
for (i=0; i<list->count; i++) {
1084
VIR_FREE(list->watches[i]->path);
1085
VIR_FREE(list->watches[i]->token);
1086
VIR_FREE(list->watches[i]);
1092
* The caller must hold the lock on the privateData
1093
* associated with the 'conn' parameter.
1095
int xenStoreAddWatch(virConnectPtr conn,
1098
xenStoreWatchCallback cb,
1101
xenStoreWatchPtr watch;
1103
xenStoreWatchListPtr list;
1104
xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData;
1106
if (priv->xshandle == NULL)
1109
list = priv->xsWatchList;
1113
/* check if we already have this callback on our list */
1114
for (n=0; n < list->count; n++) {
1115
if( STREQ(list->watches[n]->path, path) &&
1116
STREQ(list->watches[n]->token, token)) {
1117
virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR,
1118
"%s", _("watch already tracked"));
1123
if (VIR_ALLOC(watch) < 0)
1125
watch->path = strdup(path);
1126
watch->token = strdup(token);
1128
watch->opaque = opaque;
1130
/* Make space on list */
1132
if (VIR_REALLOC_N(list->watches, n + 1) < 0) {
1133
virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR,
1134
"%s", _("reallocating list"));
1139
list->watches[n] = watch;
1144
return xs_watch(priv->xshandle, watch->path, watch->token);
1148
* The caller must hold the lock on the privateData
1149
* associated with the 'conn' parameter.
1151
int xenStoreRemoveWatch(virConnectPtr conn,
1156
xenStoreWatchListPtr list;
1157
xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData;
1159
if (priv->xshandle == NULL)
1162
list = priv->xsWatchList;
1166
for (i = 0 ; i < list->count ; i++) {
1167
if( STREQ(list->watches[i]->path, path) &&
1168
STREQ(list->watches[i]->token, token)) {
1170
if (!xs_unwatch(priv->xshandle,
1171
list->watches[i]->path,
1172
list->watches[i]->token))
1174
DEBUG0("WARNING: Could not remove watch");
1175
/* Not fatal, continue */
1178
VIR_FREE(list->watches[i]->path);
1179
VIR_FREE(list->watches[i]->token);
1180
VIR_FREE(list->watches[i]);
1182
if (i < (list->count - 1))
1183
memmove(list->watches + i,
1184
list->watches + i + 1,
1185
sizeof(*(list->watches)) *
1186
(list->count - (i + 1)));
1188
if (VIR_REALLOC_N(list->watches,
1189
list->count - 1) < 0) {
1190
; /* Failure to reduce memory allocation isn't fatal */
1193
virUnrefConnect(conn);
1200
static xenStoreWatchPtr
1201
xenStoreFindWatch(xenStoreWatchListPtr list,
1206
for (i = 0 ; i < list->count ; i++)
1207
if( STREQ(path, list->watches[i]->path) &&
1208
STREQ(token, list->watches[i]->token) )
1209
return list->watches[i];
1215
xenStoreWatchEvent(int watch ATTRIBUTE_UNUSED,
1216
int fd ATTRIBUTE_UNUSED,
1223
unsigned int stringCount;
1224
xenStoreWatchPtr sw;
1226
virConnectPtr conn = data;
1227
xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData;
1231
/* only set a watch on read and write events */
1232
if (events & (VIR_EVENT_HANDLE_ERROR | VIR_EVENT_HANDLE_HANGUP)) return;
1234
xenUnifiedLock(priv);
1239
event = xs_read_watch(priv->xshandle, &stringCount);
1243
path = event[XS_WATCH_PATH];
1244
token = event[XS_WATCH_TOKEN];
1246
sw = xenStoreFindWatch(priv->xsWatchList, path, token);
1248
sw->cb(conn, path, token, sw->opaque);
1252
xenUnifiedUnlock(priv);
1257
* The domain callback for the @introduceDomain watch
1259
* The lock on 'priv' is held when calling this
1261
int xenStoreDomainIntroduced(virConnectPtr conn,
1262
const char *path ATTRIBUTE_UNUSED,
1263
const char *token ATTRIBUTE_UNUSED,
1266
int i, j, found, missing = 0, retries = 20;
1271
xenUnifiedPrivatePtr priv = opaque;
1274
new_domain_cnt = xenStoreNumOfDomains(conn);
1275
if( VIR_ALLOC_N(new_domids,new_domain_cnt) < 0 ) {
1276
virReportOOMError(NULL);
1279
nread = xenStoreDoListDomains(priv, new_domids, new_domain_cnt);
1280
if (nread != new_domain_cnt) {
1281
// mismatch. retry this read
1282
VIR_FREE(new_domids);
1287
for (i=0 ; i < new_domain_cnt ; i++) {
1289
for (j = 0 ; j < priv->activeDomainList->count ; j++) {
1290
if (priv->activeDomainList->doms[j]->id == new_domids[i]) {
1297
virDomainEventPtr event;
1299
unsigned char uuid[VIR_UUID_BUFLEN];
1301
if (!(name = xenStoreDomainGetName(conn, new_domids[i]))) {
1305
if (xenStoreDomainGetUUID(conn, new_domids[i], uuid) < 0) {
1311
event = virDomainEventNew(new_domids[i], name, uuid,
1312
VIR_DOMAIN_EVENT_STARTED,
1313
VIR_DOMAIN_EVENT_STARTED_BOOTED);
1315
xenUnifiedDomainEventDispatch(priv, event);
1317
/* Add to the list */
1318
xenUnifiedAddDomainInfo(priv->activeDomainList,
1319
new_domids[i], name, uuid);
1324
VIR_FREE(new_domids);
1326
if (missing && retries--) {
1327
DEBUG0("Some domains were missing, trying again");
1335
* The domain callback for the @destroyDomain watch
1337
* The lock on 'priv' is held when calling this
1339
int xenStoreDomainReleased(virConnectPtr conn,
1340
const char *path ATTRIBUTE_UNUSED,
1341
const char *token ATTRIBUTE_UNUSED,
1344
int i, j, found, removed, retries = 20;
1349
xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) opaque;
1351
if(!priv->activeDomainList->count) return 0;
1354
new_domain_cnt = xenStoreNumOfDomains(conn);
1356
if( VIR_ALLOC_N(new_domids,new_domain_cnt) < 0 ) {
1357
virReportOOMError(NULL);
1360
nread = xenStoreDoListDomains(priv, new_domids, new_domain_cnt);
1361
if (nread != new_domain_cnt) {
1362
// mismatch. retry this read
1363
VIR_FREE(new_domids);
1368
for (j=0 ; j < priv->activeDomainList->count ; j++) {
1370
for (i=0 ; i < new_domain_cnt ; i++) {
1371
if (priv->activeDomainList->doms[j]->id == new_domids[i]) {
1378
virDomainEventPtr event =
1379
virDomainEventNew(-1,
1380
priv->activeDomainList->doms[j]->name,
1381
priv->activeDomainList->doms[j]->uuid,
1382
VIR_DOMAIN_EVENT_STOPPED,
1383
VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN);
1385
xenUnifiedDomainEventDispatch(priv, event);
1387
/* Remove from the list */
1388
xenUnifiedRemoveDomainInfo(priv->activeDomainList,
1389
priv->activeDomainList->doms[j]->id,
1390
priv->activeDomainList->doms[j]->name,
1391
priv->activeDomainList->doms[j]->uuid);
1397
VIR_FREE(new_domids);
1399
if (!removed && retries--) {
1400
DEBUG0("No domains removed, retrying");
added
removed
src/xs_internal.c
