int r;
NONBLOCKING (r = virConnectClose (conn));
- CHECK_ERROR (r == -1, conn, "virConnectClose");
+ CHECK_ERROR (r == -1, "virConnectClose");
/* So that we don't double-free in the finalizer: */
Connect_val (connv) = NULL;
char *r;
NONBLOCKING (r = virConnectGetHostname (conn));
- CHECK_ERROR (!r, conn, "virConnectGetHostname");
+ CHECK_ERROR (!r, "virConnectGetHostname");
rv = caml_copy_string (r);
free (r);
char *r;
NONBLOCKING (r = virConnectGetURI (conn));
- CHECK_ERROR (!r, conn, "virConnectGetURI");
+ CHECK_ERROR (!r, "virConnectGetURI");
rv = caml_copy_string (r);
free (r);
const char *r;
NONBLOCKING (r = virConnectGetType (conn));
- CHECK_ERROR (!r, conn, "virConnectGetType");
+ CHECK_ERROR (!r, "virConnectGetType");
rv = caml_copy_string (r);
CAMLreturn (rv);
int r;
NONBLOCKING (r = virConnectNumOfDomains (conn));
- CHECK_ERROR (r == -1, conn, "virConnectNumOfDomains");
+ CHECK_ERROR (r == -1, "virConnectNumOfDomains");
CAMLreturn (Val_int (r));
}
}
NONBLOCKING (r = virConnectListDomains (conn, ids, i));
- CHECK_ERROR (r == -1, conn, "virConnectListDomains");
+ CHECK_ERROR (r == -1, "virConnectListDomains");
rv = caml_alloc (r, 0);
for (i = 0; i < r; ++i)
int r;
NONBLOCKING (r = virConnectNumOfDefinedDomains (conn));
- CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedDomains");
+ CHECK_ERROR (r == -1, "virConnectNumOfDefinedDomains");
CAMLreturn (Val_int (r));
}
}
NONBLOCKING (r = virConnectListDefinedDomains (conn, names, i));
- CHECK_ERROR (r == -1, conn, "virConnectListDefinedDomains");
+ CHECK_ERROR (r == -1, "virConnectListDefinedDomains");
rv = caml_alloc (r, 0);
for (i = 0; i < r; ++i) {
int r;
NONBLOCKING (r = virConnectNumOfNetworks (conn));
- CHECK_ERROR (r == -1, conn, "virConnectNumOfNetworks");
+ CHECK_ERROR (r == -1, "virConnectNumOfNetworks");
CAMLreturn (Val_int (r));
}
}
NONBLOCKING (r = virConnectListNetworks (conn, names, i));
- CHECK_ERROR (r == -1, conn, "virConnectListNetworks");
+ CHECK_ERROR (r == -1, "virConnectListNetworks");
rv = caml_alloc (r, 0);
for (i = 0; i < r; ++i) {
int r;
NONBLOCKING (r = virConnectNumOfDefinedNetworks (conn));
- CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedNetworks");
+ CHECK_ERROR (r == -1, "virConnectNumOfDefinedNetworks");
CAMLreturn (Val_int (r));
}
}
NONBLOCKING (r = virConnectListDefinedNetworks (conn, names, i));
- CHECK_ERROR (r == -1, conn, "virConnectListDefinedNetworks");
+ CHECK_ERROR (r == -1, "virConnectListDefinedNetworks");
rv = caml_alloc (r, 0);
for (i = 0; i < r; ++i) {
int r;
NONBLOCKING (r = virConnectNumOfStoragePools (conn));
- CHECK_ERROR (r == -1, conn, "virConnectNumOfStoragePools");
+ CHECK_ERROR (r == -1, "virConnectNumOfStoragePools");
CAMLreturn (Val_int (r));
}
}
NONBLOCKING (r = virConnectListStoragePools (conn, names, i));
- CHECK_ERROR (r == -1, conn, "virConnectListStoragePools");
+ CHECK_ERROR (r == -1, "virConnectListStoragePools");
rv = caml_alloc (r, 0);
for (i = 0; i < r; ++i) {
int r;
NONBLOCKING (r = virConnectNumOfDefinedStoragePools (conn));
- CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedStoragePools");
+ CHECK_ERROR (r == -1, "virConnectNumOfDefinedStoragePools");
CAMLreturn (Val_int (r));
}
}
NONBLOCKING (r = virConnectListDefinedStoragePools (conn, names, i));
- CHECK_ERROR (r == -1, conn, "virConnectListDefinedStoragePools");
+ CHECK_ERROR (r == -1, "virConnectListDefinedStoragePools");
rv = caml_alloc (r, 0);
for (i = 0; i < r; ++i) {
char *r;
NONBLOCKING (r = virConnectGetCapabilities (conn));
- CHECK_ERROR (!r, conn, "virConnectGetCapabilities");
+ CHECK_ERROR (!r, "virConnectGetCapabilities");
rv = caml_copy_string (r);
free (r);
int r;
NONBLOCKING (r = virConnectDomainEventDeregisterAny (conn, i));
- CHECK_ERROR (r == -1, conn, "virConnectDomainEventDeregisterAny");
+ CHECK_ERROR (r == -1, "virConnectDomainEventDeregisterAny");
CAMLreturn (Val_unit);
}
virDomainPtr r;
NONBLOCKING (r = virDomainCreateLinux (conn, str, 0));
- CHECK_ERROR (!r, conn, "virDomainCreateLinux");
+ CHECK_ERROR (!r, "virDomainCreateLinux");
rv = Val_domain (r, connv);
virDomainPtr r;
NONBLOCKING (r = virDomainCreateXML (conn, str, u));
- CHECK_ERROR (!r, conn, "virDomainCreateXML");
+ CHECK_ERROR (!r, "virDomainCreateXML");
rv = Val_domain (r, connv);
CAMLparam1 (domv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r;
NONBLOCKING (r = virDomainFree (dom));
- CHECK_ERROR (r == -1, conn, "virDomainFree");
+ CHECK_ERROR (r == -1, "virDomainFree");
/* So that we don't double-free in the finalizer: */
Domain_val (domv) = NULL;
CAMLparam1 (domv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r;
NONBLOCKING (r = virDomainDestroy (dom));
- CHECK_ERROR (r == -1, conn, "virDomainDestroy");
+ CHECK_ERROR (r == -1, "virDomainDestroy");
/* So that we don't double-free in the finalizer: */
Domain_val (domv) = NULL;
virDomainPtr r;
NONBLOCKING (r = virDomainLookupByName (conn, str));
- CHECK_ERROR (!r, conn, "virDomainLookupByName");
+ CHECK_ERROR (!r, "virDomainLookupByName");
rv = Val_domain (r, connv);
virDomainPtr r;
NONBLOCKING (r = virDomainLookupByID (conn, i));
- CHECK_ERROR (!r, conn, "virDomainLookupByID");
+ CHECK_ERROR (!r, "virDomainLookupByID");
rv = Val_domain (r, connv);
virDomainPtr r;
NONBLOCKING (r = virDomainLookupByUUID (conn, uuid));
- CHECK_ERROR (!r, conn, "virDomainLookupByUUID");
+ CHECK_ERROR (!r, "virDomainLookupByUUID");
rv = Val_domain (r, connv);
virDomainPtr r;
NONBLOCKING (r = virDomainLookupByUUIDString (conn, str));
- CHECK_ERROR (!r, conn, "virDomainLookupByUUIDString");
+ CHECK_ERROR (!r, "virDomainLookupByUUIDString");
rv = Val_domain (r, connv);
CAMLlocal1 (rv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
const char *r;
NONBLOCKING (r = virDomainGetName (dom));
- CHECK_ERROR (!r, conn, "virDomainGetName");
+ CHECK_ERROR (!r, "virDomainGetName");
rv = caml_copy_string (r);
CAMLreturn (rv);
CAMLlocal1 (rv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
char *r;
NONBLOCKING (r = virDomainGetOSType (dom));
- CHECK_ERROR (!r, conn, "virDomainGetOSType");
+ CHECK_ERROR (!r, "virDomainGetOSType");
rv = caml_copy_string (r);
free (r);
CAMLlocal1 (rv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
char *r;
NONBLOCKING (r = virDomainGetXMLDesc (dom, 0));
- CHECK_ERROR (!r, conn, "virDomainGetXMLDesc");
+ CHECK_ERROR (!r, "virDomainGetXMLDesc");
rv = caml_copy_string (r);
free (r);
CAMLlocal1 (rv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
unsigned char uuid[VIR_UUID_BUFLEN];
int r;
NONBLOCKING (r = virDomainGetUUID (dom, uuid));
- CHECK_ERROR (r == -1, conn, "virDomainGetUUID");
+ CHECK_ERROR (r == -1, "virDomainGetUUID");
/* UUIDs are byte arrays with a fixed length. */
rv = caml_alloc_string (VIR_UUID_BUFLEN);
CAMLlocal1 (rv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
char uuid[VIR_UUID_STRING_BUFLEN];
int r;
NONBLOCKING (r = virDomainGetUUIDString (dom, uuid));
- CHECK_ERROR (r == -1, conn, "virDomainGetUUIDString");
+ CHECK_ERROR (r == -1, "virDomainGetUUIDString");
rv = caml_copy_string (uuid);
CAMLreturn (rv);
CAMLparam1 (domv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r;
NONBLOCKING (r = virDomainGetMaxVcpus (dom));
- CHECK_ERROR (r == -1, conn, "virDomainGetMaxVcpus");
+ CHECK_ERROR (r == -1, "virDomainGetMaxVcpus");
CAMLreturn (Val_int (r));
}
CAMLparam2 (domv, strv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
char *str = String_val (strv);
int r;
NONBLOCKING (r = virDomainSave (dom, str));
- CHECK_ERROR (r == -1, conn, "virDomainSave");
+ CHECK_ERROR (r == -1, "virDomainSave");
CAMLreturn (Val_unit);
}
int r;
NONBLOCKING (r = virDomainRestore (conn, str));
- CHECK_ERROR (r == -1, conn, "virDomainRestore");
+ CHECK_ERROR (r == -1, "virDomainRestore");
CAMLreturn (Val_unit);
}
CAMLlocal1 (rv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
char *str = String_val (strv);
int r;
NONBLOCKING (r = virDomainCoreDump (dom, str, 0));
- CHECK_ERROR (!r, conn, "virDomainCoreDump");
+ CHECK_ERROR (!r, "virDomainCoreDump");
CAMLreturn (Val_unit);
}
CAMLparam1 (domv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r;
NONBLOCKING (r = virDomainSuspend (dom));
- CHECK_ERROR (r == -1, conn, "virDomainSuspend");
+ CHECK_ERROR (r == -1, "virDomainSuspend");
CAMLreturn (Val_unit);
}
CAMLparam1 (domv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r;
NONBLOCKING (r = virDomainResume (dom));
- CHECK_ERROR (r == -1, conn, "virDomainResume");
+ CHECK_ERROR (r == -1, "virDomainResume");
CAMLreturn (Val_unit);
}
CAMLparam1 (domv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r;
NONBLOCKING (r = virDomainShutdown (dom));
- CHECK_ERROR (r == -1, conn, "virDomainShutdown");
+ CHECK_ERROR (r == -1, "virDomainShutdown");
CAMLreturn (Val_unit);
}
CAMLparam1 (domv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r;
NONBLOCKING (r = virDomainReboot (dom, 0));
- CHECK_ERROR (r == -1, conn, "virDomainReboot");
+ CHECK_ERROR (r == -1, "virDomainReboot");
CAMLreturn (Val_unit);
}
virDomainPtr r;
NONBLOCKING (r = virDomainDefineXML (conn, str));
- CHECK_ERROR (!r, conn, "virDomainDefineXML");
+ CHECK_ERROR (!r, "virDomainDefineXML");
rv = Val_domain (r, connv);
CAMLparam1 (domv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r;
NONBLOCKING (r = virDomainUndefine (dom));
- CHECK_ERROR (r == -1, conn, "virDomainUndefine");
+ CHECK_ERROR (r == -1, "virDomainUndefine");
CAMLreturn (Val_unit);
}
CAMLparam1 (domv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r;
NONBLOCKING (r = virDomainCreate (dom));
- CHECK_ERROR (r == -1, conn, "virDomainCreate");
+ CHECK_ERROR (r == -1, "virDomainCreate");
CAMLreturn (Val_unit);
}
CAMLparam2 (domv, strv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
char *str = String_val (strv);
int r;
NONBLOCKING (r = virDomainAttachDevice (dom, str));
- CHECK_ERROR (r == -1, conn, "virDomainAttachDevice");
+ CHECK_ERROR (r == -1, "virDomainAttachDevice");
CAMLreturn (Val_unit);
}
CAMLparam2 (domv, strv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
char *str = String_val (strv);
int r;
NONBLOCKING (r = virDomainDetachDevice (dom, str));
- CHECK_ERROR (r == -1, conn, "virDomainDetachDevice");
+ CHECK_ERROR (r == -1, "virDomainDetachDevice");
CAMLreturn (Val_unit);
}
CAMLparam1 (domv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r, b;
NONBLOCKING (r = virDomainGetAutostart (dom, &b));
- CHECK_ERROR (r == -1, conn, "virDomainGetAutostart");
+ CHECK_ERROR (r == -1, "virDomainGetAutostart");
CAMLreturn (b ? Val_true : Val_false);
}
CAMLparam2 (domv, bv);
virDomainPtr dom = Domain_val (domv);
- virConnectPtr conn = Connect_domv (domv);
int r, b;
b = bv == Val_true ? 1 : 0;
NONBLOCKING (r = virDomainSetAutostart (dom, b));
- CHECK_ERROR (r == -1, conn, "virDomainSetAutostart");
+ CHECK_ERROR (r == -1, "virDomainSetAutostart");
CAMLreturn (Val_unit);
}
CAMLparam1 (netv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
int r;
NONBLOCKING (r = virNetworkFree (net));
- CHECK_ERROR (r == -1, conn, "virNetworkFree");
+ CHECK_ERROR (r == -1, "virNetworkFree");
/* So that we don't double-free in the finalizer: */
Network_val (netv) = NULL;
CAMLparam1 (netv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
int r;
NONBLOCKING (r = virNetworkDestroy (net));
- CHECK_ERROR (r == -1, conn, "virNetworkDestroy");
+ CHECK_ERROR (r == -1, "virNetworkDestroy");
/* So that we don't double-free in the finalizer: */
Network_val (netv) = NULL;
virNetworkPtr r;
NONBLOCKING (r = virNetworkLookupByName (conn, str));
- CHECK_ERROR (!r, conn, "virNetworkLookupByName");
+ CHECK_ERROR (!r, "virNetworkLookupByName");
rv = Val_network (r, connv);
virNetworkPtr r;
NONBLOCKING (r = virNetworkLookupByUUID (conn, uuid));
- CHECK_ERROR (!r, conn, "virNetworkLookupByUUID");
+ CHECK_ERROR (!r, "virNetworkLookupByUUID");
rv = Val_network (r, connv);
virNetworkPtr r;
NONBLOCKING (r = virNetworkLookupByUUIDString (conn, str));
- CHECK_ERROR (!r, conn, "virNetworkLookupByUUIDString");
+ CHECK_ERROR (!r, "virNetworkLookupByUUIDString");
rv = Val_network (r, connv);
CAMLlocal1 (rv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
const char *r;
NONBLOCKING (r = virNetworkGetName (net));
- CHECK_ERROR (!r, conn, "virNetworkGetName");
+ CHECK_ERROR (!r, "virNetworkGetName");
rv = caml_copy_string (r);
CAMLreturn (rv);
CAMLlocal1 (rv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
char *r;
NONBLOCKING (r = virNetworkGetXMLDesc (net, 0));
- CHECK_ERROR (!r, conn, "virNetworkGetXMLDesc");
+ CHECK_ERROR (!r, "virNetworkGetXMLDesc");
rv = caml_copy_string (r);
free (r);
CAMLlocal1 (rv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
char *r;
NONBLOCKING (r = virNetworkGetBridgeName (net));
- CHECK_ERROR (!r, conn, "virNetworkGetBridgeName");
+ CHECK_ERROR (!r, "virNetworkGetBridgeName");
rv = caml_copy_string (r);
free (r);
CAMLlocal1 (rv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
unsigned char uuid[VIR_UUID_BUFLEN];
int r;
NONBLOCKING (r = virNetworkGetUUID (net, uuid));
- CHECK_ERROR (r == -1, conn, "virNetworkGetUUID");
+ CHECK_ERROR (r == -1, "virNetworkGetUUID");
/* UUIDs are byte arrays with a fixed length. */
rv = caml_alloc_string (VIR_UUID_BUFLEN);
CAMLlocal1 (rv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
char uuid[VIR_UUID_STRING_BUFLEN];
int r;
NONBLOCKING (r = virNetworkGetUUIDString (net, uuid));
- CHECK_ERROR (r == -1, conn, "virNetworkGetUUIDString");
+ CHECK_ERROR (r == -1, "virNetworkGetUUIDString");
rv = caml_copy_string (uuid);
CAMLreturn (rv);
CAMLparam1 (netv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
int r;
NONBLOCKING (r = virNetworkUndefine (net));
- CHECK_ERROR (r == -1, conn, "virNetworkUndefine");
+ CHECK_ERROR (r == -1, "virNetworkUndefine");
CAMLreturn (Val_unit);
}
virNetworkPtr r;
NONBLOCKING (r = virNetworkCreateXML (conn, str));
- CHECK_ERROR (!r, conn, "virNetworkCreateXML");
+ CHECK_ERROR (!r, "virNetworkCreateXML");
rv = Val_network (r, connv);
virNetworkPtr r;
NONBLOCKING (r = virNetworkDefineXML (conn, str));
- CHECK_ERROR (!r, conn, "virNetworkDefineXML");
+ CHECK_ERROR (!r, "virNetworkDefineXML");
rv = Val_network (r, connv);
CAMLparam1 (netv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
int r;
NONBLOCKING (r = virNetworkCreate (net));
- CHECK_ERROR (r == -1, conn, "virNetworkCreate");
+ CHECK_ERROR (r == -1, "virNetworkCreate");
CAMLreturn (Val_unit);
}
CAMLparam1 (netv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
int r, b;
NONBLOCKING (r = virNetworkGetAutostart (net, &b));
- CHECK_ERROR (r == -1, conn, "virNetworkGetAutostart");
+ CHECK_ERROR (r == -1, "virNetworkGetAutostart");
CAMLreturn (b ? Val_true : Val_false);
}
CAMLparam2 (netv, bv);
virNetworkPtr net = Network_val (netv);
- virConnectPtr conn = Connect_netv (netv);
int r, b;
b = bv == Val_true ? 1 : 0;
NONBLOCKING (r = virNetworkSetAutostart (net, b));
- CHECK_ERROR (r == -1, conn, "virNetworkSetAutostart");
+ CHECK_ERROR (r == -1, "virNetworkSetAutostart");
CAMLreturn (Val_unit);
}
CAMLparam1 (poolv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
int r;
NONBLOCKING (r = virStoragePoolFree (pool));
- CHECK_ERROR (r == -1, conn, "virStoragePoolFree");
+ CHECK_ERROR (r == -1, "virStoragePoolFree");
/* So that we don't double-free in the finalizer: */
Pool_val (poolv) = NULL;
CAMLparam1 (poolv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
int r;
NONBLOCKING (r = virStoragePoolDestroy (pool));
- CHECK_ERROR (r == -1, conn, "virStoragePoolDestroy");
+ CHECK_ERROR (r == -1, "virStoragePoolDestroy");
/* So that we don't double-free in the finalizer: */
Pool_val (poolv) = NULL;
virStoragePoolPtr r;
NONBLOCKING (r = virStoragePoolLookupByName (conn, str));
- CHECK_ERROR (!r, conn, "virStoragePoolLookupByName");
+ CHECK_ERROR (!r, "virStoragePoolLookupByName");
rv = Val_pool (r, connv);
virStoragePoolPtr r;
NONBLOCKING (r = virStoragePoolLookupByUUID (conn, uuid));
- CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUID");
+ CHECK_ERROR (!r, "virStoragePoolLookupByUUID");
rv = Val_pool (r, connv);
virStoragePoolPtr r;
NONBLOCKING (r = virStoragePoolLookupByUUIDString (conn, str));
- CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUIDString");
+ CHECK_ERROR (!r, "virStoragePoolLookupByUUIDString");
rv = Val_pool (r, connv);
CAMLlocal1 (rv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
const char *r;
NONBLOCKING (r = virStoragePoolGetName (pool));
- CHECK_ERROR (!r, conn, "virStoragePoolGetName");
+ CHECK_ERROR (!r, "virStoragePoolGetName");
rv = caml_copy_string (r);
CAMLreturn (rv);
CAMLlocal1 (rv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
char *r;
NONBLOCKING (r = virStoragePoolGetXMLDesc (pool, 0));
- CHECK_ERROR (!r, conn, "virStoragePoolGetXMLDesc");
+ CHECK_ERROR (!r, "virStoragePoolGetXMLDesc");
rv = caml_copy_string (r);
free (r);
CAMLlocal1 (rv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
unsigned char uuid[VIR_UUID_BUFLEN];
int r;
NONBLOCKING (r = virStoragePoolGetUUID (pool, uuid));
- CHECK_ERROR (r == -1, conn, "virStoragePoolGetUUID");
+ CHECK_ERROR (r == -1, "virStoragePoolGetUUID");
/* UUIDs are byte arrays with a fixed length. */
rv = caml_alloc_string (VIR_UUID_BUFLEN);
CAMLlocal1 (rv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
char uuid[VIR_UUID_STRING_BUFLEN];
int r;
NONBLOCKING (r = virStoragePoolGetUUIDString (pool, uuid));
- CHECK_ERROR (r == -1, conn, "virStoragePoolGetUUIDString");
+ CHECK_ERROR (r == -1, "virStoragePoolGetUUIDString");
rv = caml_copy_string (uuid);
CAMLreturn (rv);
virStoragePoolPtr r;
NONBLOCKING (r = virStoragePoolCreateXML (conn, str, 0));
- CHECK_ERROR (!r, conn, "virStoragePoolCreateXML");
+ CHECK_ERROR (!r, "virStoragePoolCreateXML");
rv = Val_pool (r, connv);
virStoragePoolPtr r;
NONBLOCKING (r = virStoragePoolDefineXML (conn, str, 0));
- CHECK_ERROR (!r, conn, "virStoragePoolDefineXML");
+ CHECK_ERROR (!r, "virStoragePoolDefineXML");
rv = Val_pool (r, connv);
CAMLparam2 (poolv, iv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
unsigned int i = Int_val (iv);
int r;
NONBLOCKING (r = virStoragePoolBuild (pool, i));
- CHECK_ERROR (r == -1, conn, "virStoragePoolBuild");
+ CHECK_ERROR (r == -1, "virStoragePoolBuild");
CAMLreturn (Val_unit);
}
CAMLparam1 (poolv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
int r;
NONBLOCKING (r = virStoragePoolUndefine (pool));
- CHECK_ERROR (r == -1, conn, "virStoragePoolUndefine");
+ CHECK_ERROR (r == -1, "virStoragePoolUndefine");
CAMLreturn (Val_unit);
}
CAMLparam1 (poolv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
int r;
NONBLOCKING (r = virStoragePoolCreate (pool, 0));
- CHECK_ERROR (r == -1, conn, "virStoragePoolCreate");
+ CHECK_ERROR (r == -1, "virStoragePoolCreate");
CAMLreturn (Val_unit);
}
CAMLparam2 (poolv, iv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
unsigned int i = Int_val (iv);
int r;
NONBLOCKING (r = virStoragePoolDelete (pool, i));
- CHECK_ERROR (r == -1, conn, "virStoragePoolDelete");
+ CHECK_ERROR (r == -1, "virStoragePoolDelete");
CAMLreturn (Val_unit);
}
CAMLparam1 (poolv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
int r;
NONBLOCKING (r = virStoragePoolRefresh (pool, 0));
- CHECK_ERROR (r == -1, conn, "virStoragePoolRefresh");
+ CHECK_ERROR (r == -1, "virStoragePoolRefresh");
CAMLreturn (Val_unit);
}
CAMLparam1 (poolv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
int r, b;
NONBLOCKING (r = virStoragePoolGetAutostart (pool, &b));
- CHECK_ERROR (r == -1, conn, "virStoragePoolGetAutostart");
+ CHECK_ERROR (r == -1, "virStoragePoolGetAutostart");
CAMLreturn (b ? Val_true : Val_false);
}
CAMLparam2 (poolv, bv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
int r, b;
b = bv == Val_true ? 1 : 0;
NONBLOCKING (r = virStoragePoolSetAutostart (pool, b));
- CHECK_ERROR (r == -1, conn, "virStoragePoolSetAutostart");
+ CHECK_ERROR (r == -1, "virStoragePoolSetAutostart");
CAMLreturn (Val_unit);
}
CAMLparam1 (poolv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
int r;
NONBLOCKING (r = virStoragePoolNumOfVolumes (pool));
- CHECK_ERROR (r == -1, conn, "virStoragePoolNumOfVolumes");
+ CHECK_ERROR (r == -1, "virStoragePoolNumOfVolumes");
CAMLreturn (Val_int (r));
}
CAMLlocal2 (rv, strv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
int i = Int_val (iv);
char *names[i];
int r;
}
NONBLOCKING (r = virStoragePoolListVolumes (pool, names, i));
- CHECK_ERROR (r == -1, conn, "virStoragePoolListVolumes");
+ CHECK_ERROR (r == -1, "virStoragePoolListVolumes");
rv = caml_alloc (r, 0);
for (i = 0; i < r; ++i) {
CAMLparam1 (volv);
virStorageVolPtr vol = Volume_val (volv);
- virConnectPtr conn = Connect_volv (volv);
int r;
NONBLOCKING (r = virStorageVolFree (vol));
- CHECK_ERROR (r == -1, conn, "virStorageVolFree");
+ CHECK_ERROR (r == -1, "virStorageVolFree");
/* So that we don't double-free in the finalizer: */
Volume_val (volv) = NULL;
CAMLparam2 (volv, iv);
virStorageVolPtr vol = Volume_val (volv);
- virConnectPtr conn = Connect_volv (volv);
unsigned int i = Int_val (iv);
int r;
NONBLOCKING (r = virStorageVolDelete (vol, i));
- CHECK_ERROR (r == -1, conn, "virStorageVolDelete");
+ CHECK_ERROR (r == -1, "virStorageVolDelete");
CAMLreturn (Val_unit);
}
CAMLlocal2 (rv, connv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
char *str = String_val (strv);
virStorageVolPtr r;
NONBLOCKING (r = virStorageVolLookupByName (pool, str));
- CHECK_ERROR (!r, conn, "virStorageVolLookupByName");
+ CHECK_ERROR (!r, "virStorageVolLookupByName");
connv = Field (poolv, 1);
rv = Val_volume (r, connv);
virStorageVolPtr r;
NONBLOCKING (r = virStorageVolLookupByKey (conn, str));
- CHECK_ERROR (!r, conn, "virStorageVolLookupByKey");
+ CHECK_ERROR (!r, "virStorageVolLookupByKey");
rv = Val_volume (r, connv);
virStorageVolPtr r;
NONBLOCKING (r = virStorageVolLookupByPath (conn, str));
- CHECK_ERROR (!r, conn, "virStorageVolLookupByPath");
+ CHECK_ERROR (!r, "virStorageVolLookupByPath");
rv = Val_volume (r, connv);
CAMLlocal2 (rv, connv);
virStoragePoolPtr pool = Pool_val (poolv);
- virConnectPtr conn = Connect_polv (poolv);
char *str = String_val (strv);
virStorageVolPtr r;
NONBLOCKING (r = virStorageVolCreateXML (pool, str, 0));
- CHECK_ERROR (!r, conn, "virStorageVolCreateXML");
+ CHECK_ERROR (!r, "virStorageVolCreateXML");
connv = Field (poolv, 1);
rv = Val_volume (r, connv);
CAMLlocal1 (rv);
virStorageVolPtr vol = Volume_val (volv);
- virConnectPtr conn = Connect_volv (volv);
char *r;
NONBLOCKING (r = virStorageVolGetXMLDesc (vol, 0));
- CHECK_ERROR (!r, conn, "virStorageVolGetXMLDesc");
+ CHECK_ERROR (!r, "virStorageVolGetXMLDesc");
rv = caml_copy_string (r);
free (r);
CAMLlocal1 (rv);
virStorageVolPtr vol = Volume_val (volv);
- virConnectPtr conn = Connect_volv (volv);
char *r;
NONBLOCKING (r = virStorageVolGetPath (vol));
- CHECK_ERROR (!r, conn, "virStorageVolGetPath");
+ CHECK_ERROR (!r, "virStorageVolGetPath");
rv = caml_copy_string (r);
free (r);
CAMLlocal1 (rv);
virStorageVolPtr vol = Volume_val (volv);
- virConnectPtr conn = Connect_volv (volv);
const char *r;
NONBLOCKING (r = virStorageVolGetKey (vol));
- CHECK_ERROR (!r, conn, "virStorageVolGetKey");
+ CHECK_ERROR (!r, "virStorageVolGetKey");
rv = caml_copy_string (r);
CAMLreturn (rv);
CAMLlocal1 (rv);
virStorageVolPtr vol = Volume_val (volv);
- virConnectPtr conn = Connect_volv (volv);
const char *r;
NONBLOCKING (r = virStorageVolGetName (vol));
- CHECK_ERROR (!r, conn, "virStorageVolGetName");
+ CHECK_ERROR (!r, "virStorageVolGetName");
rv = caml_copy_string (r);
CAMLreturn (rv);
CAMLlocal2 (rv, connv);
virStorageVolPtr vol = Volume_val (volv);
- virConnectPtr conn = Connect_volv (volv);
virStoragePoolPtr r;
NONBLOCKING (r = virStoragePoolLookupByVolume (vol));
- CHECK_ERROR (!r, conn, "virStoragePoolLookupByVolume");
+ CHECK_ERROR (!r, "virStoragePoolLookupByVolume");
connv = Field (volv, 1);
rv = Val_pool (r, connv);