diff options
Diffstat (limited to 'testing/ocaml-libvirt/0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch')
| -rw-r--r-- | testing/ocaml-libvirt/0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch | 1864 |
1 files changed, 1864 insertions, 0 deletions
diff --git a/testing/ocaml-libvirt/0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch b/testing/ocaml-libvirt/0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch new file mode 100644 index 0000000000..f3655349e8 --- /dev/null +++ b/testing/ocaml-libvirt/0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch @@ -0,0 +1,1864 @@ +From 68fae1ec3de46fd9eec88fb7c1894ea7ed85ccc9 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" <rjones@redhat.com> +Date: Tue, 17 Mar 2015 12:51:50 +0000 +Subject: [PATCH 1/2] Suppress errors to stderr and use thread-local + virErrorPtr + +This allows us to capture errors that happen during virConnectOpen, +without spewing error messages on stderr. + +The patch is rather large, only because we don't need to pass the +virConnectPtr argument to CHECK_ERROR/_raise_virterror any longer. +--- + libvirt/generator.pl | 66 ++++++------ + libvirt/libvirt_c.c | 241 +++++++++++++++++-------------------------- + libvirt/libvirt_c_epilogue.c | 4 +- + libvirt/libvirt_c_oneoffs.c | 94 +++++++---------- + libvirt/libvirt_c_prologue.c | 6 +- + 5 files changed, 169 insertions(+), 242 deletions(-) + +diff --git a/libvirt/generator.pl b/libvirt/generator.pl +index 421592b..34801ba 100755 +--- a/libvirt/generator.pl ++++ b/libvirt/generator.pl +@@ -343,17 +343,13 @@ sub gen_unpack_args + if ($_ eq "conn") { + "virConnectPtr conn = Connect_val (connv);" + } elsif ($_ eq "dom") { +- "virDomainPtr dom = Domain_val (domv);\n". +- " virConnectPtr conn = Connect_domv (domv);" ++ "virDomainPtr dom = Domain_val (domv);" + } elsif ($_ eq "net") { +- "virNetworkPtr net = Network_val (netv);\n". +- " virConnectPtr conn = Connect_netv (netv);" ++ "virNetworkPtr net = Network_val (netv);" + } elsif ($_ eq "pool") { +- "virStoragePoolPtr pool = Pool_val (poolv);\n". +- " virConnectPtr conn = Connect_polv (poolv);" ++ "virStoragePoolPtr pool = Pool_val (poolv);" + } elsif ($_ eq "vol") { +- "virStorageVolPtr vol = Volume_val (volv);\n". +- " virConnectPtr conn = Connect_volv (volv);" ++ "virStorageVolPtr vol = Volume_val (volv);" + } else { + die "unknown short name $_" + } +@@ -402,7 +398,7 @@ sub gen_c_code + char *r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + rv = caml_copy_string (r); + free (r); +@@ -415,7 +411,7 @@ sub gen_c_code + const char *r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + rv = caml_copy_string (r); + CAMLreturn (rv); +@@ -426,7 +422,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_int (r)); + " +@@ -438,7 +434,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, uuid)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + /* UUIDs are byte arrays with a fixed length. */ + rv = caml_alloc_string (VIR_UUID_BUFLEN); +@@ -453,7 +449,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, uuid)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + rv = caml_copy_string (uuid); + CAMLreturn (rv); +@@ -464,7 +460,7 @@ sub gen_c_code + int r, b; + + NONBLOCKING (r = $c_name ($1, &b)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (b ? Val_true : Val_false); + " +@@ -476,7 +472,7 @@ sub gen_c_code + b = bv == Val_true ? 1 : 0; + + NONBLOCKING (r = $c_name ($1, b)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -498,7 +494,7 @@ sub gen_c_code + } + + NONBLOCKING (r = $c_name (conn, ids, i)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) +@@ -525,7 +521,7 @@ sub gen_c_code + } + + NONBLOCKING (r = $c_name ($1, names, i)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +@@ -543,7 +539,7 @@ sub gen_c_code + char *r; + + NONBLOCKING (r = $c_name ($1, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + rv = caml_copy_string (r); + free (r); +@@ -555,7 +551,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, 0)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -565,7 +561,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -575,7 +571,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + /* So that we don't double-free in the finalizer: */ + " . gen_free_arg ($1) . " +@@ -589,7 +585,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, str)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -601,7 +597,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, str, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -614,7 +610,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, str)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -629,7 +625,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, str, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -645,7 +641,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, str, u)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -659,7 +655,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, i)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -673,7 +669,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, i)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($3) . " + +@@ -688,7 +684,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, uuid)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -702,7 +698,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -716,7 +712,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -731,7 +727,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, str)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + connv = Field ($3v, 1); + " . gen_pack_result ($2) . " +@@ -747,7 +743,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, str, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + connv = Field ($3v, 1); + " . gen_pack_result ($2) . " +@@ -762,7 +758,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + connv = Field ($3v, 1); + " . gen_pack_result ($2) . " +@@ -777,7 +773,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + connv = Field ($3v, 1); + " . gen_pack_result ($2) . " +diff --git a/libvirt/libvirt_c.c b/libvirt/libvirt_c.c +index 6e56682..8d51944 100644 +--- a/libvirt/libvirt_c.c ++++ b/libvirt/libvirt_c.c +@@ -61,7 +61,7 @@ ocaml_libvirt_connect_close (value connv) + 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; +@@ -83,7 +83,7 @@ ocaml_libvirt_connect_get_hostname (value connv) + char *r; + + NONBLOCKING (r = virConnectGetHostname (conn)); +- CHECK_ERROR (!r, conn, "virConnectGetHostname"); ++ CHECK_ERROR (!r, "virConnectGetHostname"); + + rv = caml_copy_string (r); + free (r); +@@ -104,7 +104,7 @@ ocaml_libvirt_connect_get_uri (value connv) + char *r; + + NONBLOCKING (r = virConnectGetURI (conn)); +- CHECK_ERROR (!r, conn, "virConnectGetURI"); ++ CHECK_ERROR (!r, "virConnectGetURI"); + + rv = caml_copy_string (r); + free (r); +@@ -125,7 +125,7 @@ ocaml_libvirt_connect_get_type (value connv) + const char *r; + + NONBLOCKING (r = virConnectGetType (conn)); +- CHECK_ERROR (!r, conn, "virConnectGetType"); ++ CHECK_ERROR (!r, "virConnectGetType"); + + rv = caml_copy_string (r); + CAMLreturn (rv); +@@ -144,7 +144,7 @@ ocaml_libvirt_connect_num_of_domains (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfDomains (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfDomains"); ++ CHECK_ERROR (r == -1, "virConnectNumOfDomains"); + + CAMLreturn (Val_int (r)); + } +@@ -174,7 +174,7 @@ ocaml_libvirt_connect_list_domains (value connv, value iv) + } + + 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) +@@ -196,7 +196,7 @@ ocaml_libvirt_connect_num_of_defined_domains (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfDefinedDomains (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedDomains"); ++ CHECK_ERROR (r == -1, "virConnectNumOfDefinedDomains"); + + CAMLreturn (Val_int (r)); + } +@@ -227,7 +227,7 @@ ocaml_libvirt_connect_list_defined_domains (value connv, value iv) + } + + 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) { +@@ -252,7 +252,7 @@ ocaml_libvirt_connect_num_of_networks (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfNetworks (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfNetworks"); ++ CHECK_ERROR (r == -1, "virConnectNumOfNetworks"); + + CAMLreturn (Val_int (r)); + } +@@ -283,7 +283,7 @@ ocaml_libvirt_connect_list_networks (value connv, value iv) + } + + 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) { +@@ -308,7 +308,7 @@ ocaml_libvirt_connect_num_of_defined_networks (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfDefinedNetworks (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedNetworks"); ++ CHECK_ERROR (r == -1, "virConnectNumOfDefinedNetworks"); + + CAMLreturn (Val_int (r)); + } +@@ -339,7 +339,7 @@ ocaml_libvirt_connect_list_defined_networks (value connv, value iv) + } + + 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) { +@@ -364,7 +364,7 @@ ocaml_libvirt_connect_num_of_storage_pools (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfStoragePools (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfStoragePools"); ++ CHECK_ERROR (r == -1, "virConnectNumOfStoragePools"); + + CAMLreturn (Val_int (r)); + } +@@ -395,7 +395,7 @@ ocaml_libvirt_connect_list_storage_pools (value connv, value iv) + } + + 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) { +@@ -420,7 +420,7 @@ ocaml_libvirt_connect_num_of_defined_storage_pools (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfDefinedStoragePools (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedStoragePools"); ++ CHECK_ERROR (r == -1, "virConnectNumOfDefinedStoragePools"); + + CAMLreturn (Val_int (r)); + } +@@ -451,7 +451,7 @@ ocaml_libvirt_connect_list_defined_storage_pools (value connv, value iv) + } + + 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) { +@@ -477,7 +477,7 @@ ocaml_libvirt_connect_get_capabilities (value connv) + char *r; + + NONBLOCKING (r = virConnectGetCapabilities (conn)); +- CHECK_ERROR (!r, conn, "virConnectGetCapabilities"); ++ CHECK_ERROR (!r, "virConnectGetCapabilities"); + + rv = caml_copy_string (r); + free (r); +@@ -498,7 +498,7 @@ ocaml_libvirt_connect_domain_event_deregister_any (value connv, value iv) + int r; + + NONBLOCKING (r = virConnectDomainEventDeregisterAny (conn, i)); +- CHECK_ERROR (r == -1, conn, "virConnectDomainEventDeregisterAny"); ++ CHECK_ERROR (r == -1, "virConnectDomainEventDeregisterAny"); + + CAMLreturn (Val_unit); + } +@@ -518,7 +518,7 @@ ocaml_libvirt_domain_create_linux (value connv, value strv) + virDomainPtr r; + + NONBLOCKING (r = virDomainCreateLinux (conn, str, 0)); +- CHECK_ERROR (!r, conn, "virDomainCreateLinux"); ++ CHECK_ERROR (!r, "virDomainCreateLinux"); + + rv = Val_domain (r, connv); + +@@ -541,7 +541,7 @@ ocaml_libvirt_domain_create_xml (value connv, value strv, value uv) + virDomainPtr r; + + NONBLOCKING (r = virDomainCreateXML (conn, str, u)); +- CHECK_ERROR (!r, conn, "virDomainCreateXML"); ++ CHECK_ERROR (!r, "virDomainCreateXML"); + + rv = Val_domain (r, connv); + +@@ -558,11 +558,10 @@ ocaml_libvirt_domain_free (value domv) + 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; +@@ -580,11 +579,10 @@ ocaml_libvirt_domain_destroy (value domv) + 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; +@@ -607,7 +605,7 @@ ocaml_libvirt_domain_lookup_by_name (value connv, value strv) + virDomainPtr r; + + NONBLOCKING (r = virDomainLookupByName (conn, str)); +- CHECK_ERROR (!r, conn, "virDomainLookupByName"); ++ CHECK_ERROR (!r, "virDomainLookupByName"); + + rv = Val_domain (r, connv); + +@@ -629,7 +627,7 @@ ocaml_libvirt_domain_lookup_by_id (value connv, value iv) + virDomainPtr r; + + NONBLOCKING (r = virDomainLookupByID (conn, i)); +- CHECK_ERROR (!r, conn, "virDomainLookupByID"); ++ CHECK_ERROR (!r, "virDomainLookupByID"); + + rv = Val_domain (r, connv); + +@@ -651,7 +649,7 @@ ocaml_libvirt_domain_lookup_by_uuid (value connv, value uuidv) + virDomainPtr r; + + NONBLOCKING (r = virDomainLookupByUUID (conn, uuid)); +- CHECK_ERROR (!r, conn, "virDomainLookupByUUID"); ++ CHECK_ERROR (!r, "virDomainLookupByUUID"); + + rv = Val_domain (r, connv); + +@@ -673,7 +671,7 @@ ocaml_libvirt_domain_lookup_by_uuid_string (value connv, value strv) + virDomainPtr r; + + NONBLOCKING (r = virDomainLookupByUUIDString (conn, str)); +- CHECK_ERROR (!r, conn, "virDomainLookupByUUIDString"); ++ CHECK_ERROR (!r, "virDomainLookupByUUIDString"); + + rv = Val_domain (r, connv); + +@@ -691,11 +689,10 @@ ocaml_libvirt_domain_get_name (value domv) + + 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); +@@ -712,11 +709,10 @@ ocaml_libvirt_domain_get_os_type (value domv) + + 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); +@@ -734,11 +730,10 @@ ocaml_libvirt_domain_get_xml_desc (value domv) + + 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); +@@ -756,12 +751,11 @@ ocaml_libvirt_domain_get_uuid (value domv) + + 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); +@@ -780,12 +774,11 @@ ocaml_libvirt_domain_get_uuid_string (value domv) + + 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); +@@ -801,11 +794,10 @@ ocaml_libvirt_domain_get_max_vcpus (value domv) + 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)); + } +@@ -820,12 +812,11 @@ ocaml_libvirt_domain_save (value domv, value strv) + 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); + } +@@ -844,7 +835,7 @@ ocaml_libvirt_domain_restore (value connv, value strv) + int r; + + NONBLOCKING (r = virDomainRestore (conn, str)); +- CHECK_ERROR (r == -1, conn, "virDomainRestore"); ++ CHECK_ERROR (r == -1, "virDomainRestore"); + + CAMLreturn (Val_unit); + } +@@ -860,12 +851,11 @@ ocaml_libvirt_domain_core_dump (value domv, value strv) + + 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); + } +@@ -880,11 +870,10 @@ ocaml_libvirt_domain_suspend (value domv) + 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); + } +@@ -899,11 +888,10 @@ ocaml_libvirt_domain_resume (value domv) + 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); + } +@@ -918,11 +906,10 @@ ocaml_libvirt_domain_shutdown (value domv) + 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); + } +@@ -937,11 +924,10 @@ ocaml_libvirt_domain_reboot (value domv) + 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); + } +@@ -961,7 +947,7 @@ ocaml_libvirt_domain_define_xml (value connv, value strv) + virDomainPtr r; + + NONBLOCKING (r = virDomainDefineXML (conn, str)); +- CHECK_ERROR (!r, conn, "virDomainDefineXML"); ++ CHECK_ERROR (!r, "virDomainDefineXML"); + + rv = Val_domain (r, connv); + +@@ -978,11 +964,10 @@ ocaml_libvirt_domain_undefine (value domv) + 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); + } +@@ -997,11 +982,10 @@ ocaml_libvirt_domain_create (value domv) + 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); + } +@@ -1016,12 +1000,11 @@ ocaml_libvirt_domain_attach_device (value domv, value strv) + 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); + } +@@ -1036,12 +1019,11 @@ ocaml_libvirt_domain_detach_device (value domv, value strv) + 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); + } +@@ -1056,11 +1038,10 @@ ocaml_libvirt_domain_get_autostart (value domv) + 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); + } +@@ -1075,13 +1056,12 @@ ocaml_libvirt_domain_set_autostart (value domv, value bv) + 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); + } +@@ -1096,11 +1076,10 @@ ocaml_libvirt_network_free (value netv) + 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; +@@ -1118,11 +1097,10 @@ ocaml_libvirt_network_destroy (value netv) + 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; +@@ -1145,7 +1123,7 @@ ocaml_libvirt_network_lookup_by_name (value connv, value strv) + virNetworkPtr r; + + NONBLOCKING (r = virNetworkLookupByName (conn, str)); +- CHECK_ERROR (!r, conn, "virNetworkLookupByName"); ++ CHECK_ERROR (!r, "virNetworkLookupByName"); + + rv = Val_network (r, connv); + +@@ -1167,7 +1145,7 @@ ocaml_libvirt_network_lookup_by_uuid (value connv, value uuidv) + virNetworkPtr r; + + NONBLOCKING (r = virNetworkLookupByUUID (conn, uuid)); +- CHECK_ERROR (!r, conn, "virNetworkLookupByUUID"); ++ CHECK_ERROR (!r, "virNetworkLookupByUUID"); + + rv = Val_network (r, connv); + +@@ -1189,7 +1167,7 @@ ocaml_libvirt_network_lookup_by_uuid_string (value connv, value strv) + virNetworkPtr r; + + NONBLOCKING (r = virNetworkLookupByUUIDString (conn, str)); +- CHECK_ERROR (!r, conn, "virNetworkLookupByUUIDString"); ++ CHECK_ERROR (!r, "virNetworkLookupByUUIDString"); + + rv = Val_network (r, connv); + +@@ -1207,11 +1185,10 @@ ocaml_libvirt_network_get_name (value netv) + + 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); +@@ -1228,11 +1205,10 @@ ocaml_libvirt_network_get_xml_desc (value netv) + + 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); +@@ -1250,11 +1226,10 @@ ocaml_libvirt_network_get_bridge_name (value netv) + + 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); +@@ -1272,12 +1247,11 @@ ocaml_libvirt_network_get_uuid (value netv) + + 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); +@@ -1296,12 +1270,11 @@ ocaml_libvirt_network_get_uuid_string (value netv) + + 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); +@@ -1317,11 +1290,10 @@ ocaml_libvirt_network_undefine (value netv) + 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); + } +@@ -1341,7 +1313,7 @@ ocaml_libvirt_network_create_xml (value connv, value strv) + virNetworkPtr r; + + NONBLOCKING (r = virNetworkCreateXML (conn, str)); +- CHECK_ERROR (!r, conn, "virNetworkCreateXML"); ++ CHECK_ERROR (!r, "virNetworkCreateXML"); + + rv = Val_network (r, connv); + +@@ -1363,7 +1335,7 @@ ocaml_libvirt_network_define_xml (value connv, value strv) + virNetworkPtr r; + + NONBLOCKING (r = virNetworkDefineXML (conn, str)); +- CHECK_ERROR (!r, conn, "virNetworkDefineXML"); ++ CHECK_ERROR (!r, "virNetworkDefineXML"); + + rv = Val_network (r, connv); + +@@ -1380,11 +1352,10 @@ ocaml_libvirt_network_create (value netv) + 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); + } +@@ -1399,11 +1370,10 @@ ocaml_libvirt_network_get_autostart (value netv) + 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); + } +@@ -1418,13 +1388,12 @@ ocaml_libvirt_network_set_autostart (value netv, value bv) + 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); + } +@@ -1439,11 +1408,10 @@ ocaml_libvirt_storage_pool_free (value poolv) + 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; +@@ -1461,11 +1429,10 @@ ocaml_libvirt_storage_pool_destroy (value poolv) + 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; +@@ -1488,7 +1455,7 @@ ocaml_libvirt_storage_pool_lookup_by_name (value connv, value strv) + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolLookupByName (conn, str)); +- CHECK_ERROR (!r, conn, "virStoragePoolLookupByName"); ++ CHECK_ERROR (!r, "virStoragePoolLookupByName"); + + rv = Val_pool (r, connv); + +@@ -1510,7 +1477,7 @@ ocaml_libvirt_storage_pool_lookup_by_uuid (value connv, value uuidv) + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolLookupByUUID (conn, uuid)); +- CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUID"); ++ CHECK_ERROR (!r, "virStoragePoolLookupByUUID"); + + rv = Val_pool (r, connv); + +@@ -1532,7 +1499,7 @@ ocaml_libvirt_storage_pool_lookup_by_uuid_string (value connv, value strv) + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolLookupByUUIDString (conn, str)); +- CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUIDString"); ++ CHECK_ERROR (!r, "virStoragePoolLookupByUUIDString"); + + rv = Val_pool (r, connv); + +@@ -1550,11 +1517,10 @@ ocaml_libvirt_storage_pool_get_name (value poolv) + + 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); +@@ -1571,11 +1537,10 @@ ocaml_libvirt_storage_pool_get_xml_desc (value poolv) + + 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); +@@ -1593,12 +1558,11 @@ ocaml_libvirt_storage_pool_get_uuid (value poolv) + + 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); +@@ -1617,12 +1581,11 @@ ocaml_libvirt_storage_pool_get_uuid_string (value poolv) + + 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); +@@ -1643,7 +1606,7 @@ ocaml_libvirt_storage_pool_create_xml (value connv, value strv) + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolCreateXML (conn, str, 0)); +- CHECK_ERROR (!r, conn, "virStoragePoolCreateXML"); ++ CHECK_ERROR (!r, "virStoragePoolCreateXML"); + + rv = Val_pool (r, connv); + +@@ -1665,7 +1628,7 @@ ocaml_libvirt_storage_pool_define_xml (value connv, value strv) + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolDefineXML (conn, str, 0)); +- CHECK_ERROR (!r, conn, "virStoragePoolDefineXML"); ++ CHECK_ERROR (!r, "virStoragePoolDefineXML"); + + rv = Val_pool (r, connv); + +@@ -1682,12 +1645,11 @@ ocaml_libvirt_storage_pool_build (value poolv, value iv) + 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); + } +@@ -1702,11 +1664,10 @@ ocaml_libvirt_storage_pool_undefine (value poolv) + 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); + } +@@ -1721,11 +1682,10 @@ ocaml_libvirt_storage_pool_create (value poolv) + 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); + } +@@ -1740,12 +1700,11 @@ ocaml_libvirt_storage_pool_delete (value poolv, value iv) + 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); + } +@@ -1760,11 +1719,10 @@ ocaml_libvirt_storage_pool_refresh (value poolv) + 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); + } +@@ -1779,11 +1737,10 @@ ocaml_libvirt_storage_pool_get_autostart (value poolv) + 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); + } +@@ -1798,13 +1755,12 @@ ocaml_libvirt_storage_pool_set_autostart (value poolv, value bv) + 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); + } +@@ -1819,11 +1775,10 @@ ocaml_libvirt_storage_pool_num_of_volumes (value poolv) + 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)); + } +@@ -1839,7 +1794,6 @@ ocaml_libvirt_storage_pool_list_volumes (value poolv, value iv) + + CAMLlocal2 (rv, strv); + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + int i = Int_val (iv); + char *names[i]; + int r; +@@ -1855,7 +1809,7 @@ ocaml_libvirt_storage_pool_list_volumes (value poolv, value iv) + } + + 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) { +@@ -1877,11 +1831,10 @@ ocaml_libvirt_storage_vol_free (value volv) + 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; +@@ -1899,12 +1852,11 @@ ocaml_libvirt_storage_vol_delete (value volv, value iv) + 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); + } +@@ -1920,12 +1872,11 @@ ocaml_libvirt_storage_vol_lookup_by_name (value poolv, value strv) + + 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); +@@ -1948,7 +1899,7 @@ ocaml_libvirt_storage_vol_lookup_by_key (value connv, value strv) + virStorageVolPtr r; + + NONBLOCKING (r = virStorageVolLookupByKey (conn, str)); +- CHECK_ERROR (!r, conn, "virStorageVolLookupByKey"); ++ CHECK_ERROR (!r, "virStorageVolLookupByKey"); + + rv = Val_volume (r, connv); + +@@ -1970,7 +1921,7 @@ ocaml_libvirt_storage_vol_lookup_by_path (value connv, value strv) + virStorageVolPtr r; + + NONBLOCKING (r = virStorageVolLookupByPath (conn, str)); +- CHECK_ERROR (!r, conn, "virStorageVolLookupByPath"); ++ CHECK_ERROR (!r, "virStorageVolLookupByPath"); + + rv = Val_volume (r, connv); + +@@ -1988,12 +1939,11 @@ ocaml_libvirt_storage_vol_create_xml (value poolv, value strv) + + 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); +@@ -2012,11 +1962,10 @@ ocaml_libvirt_storage_vol_get_xml_desc (value volv) + + 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); +@@ -2034,11 +1983,10 @@ ocaml_libvirt_storage_vol_get_path (value volv) + + 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); +@@ -2056,11 +2004,10 @@ ocaml_libvirt_storage_vol_get_key (value volv) + + 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); +@@ -2077,11 +2024,10 @@ ocaml_libvirt_storage_vol_get_name (value volv) + + 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); +@@ -2098,11 +2044,10 @@ ocaml_libvirt_storage_pool_lookup_by_volume (value volv) + + 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); +diff --git a/libvirt/libvirt_c_epilogue.c b/libvirt/libvirt_c_epilogue.c +index 4649724..4972e50 100644 +--- a/libvirt/libvirt_c_epilogue.c ++++ b/libvirt/libvirt_c_epilogue.c +@@ -57,14 +57,14 @@ option_default (value option, value deflt) + #endif + + static void +-_raise_virterror (virConnectPtr conn, const char *fn) ++_raise_virterror (const char *fn) + { + CAMLparam0 (); + CAMLlocal1 (rv); + virErrorPtr errp; + struct _virError err; + +- errp = conn ? virConnGetLastError (conn) : virGetLastError (); ++ errp = virGetLastError (); + + if (!errp) { + /* Fake a _virError structure. */ +diff --git a/libvirt/libvirt_c_oneoffs.c b/libvirt/libvirt_c_oneoffs.c +index 06b3852..32e5a4b 100644 +--- a/libvirt/libvirt_c_oneoffs.c ++++ b/libvirt/libvirt_c_oneoffs.c +@@ -32,7 +32,7 @@ ocaml_libvirt_get_version (value driverv, value unit) + + typeVer_ptr = driver ? &typeVer : NULL; + NONBLOCKING (r = virGetVersion (&libVer, driver, typeVer_ptr)); +- CHECK_ERROR (r == -1, NULL, "virGetVersion"); ++ CHECK_ERROR (r == -1, "virGetVersion"); + + rv = caml_alloc_tuple (2); + Store_field (rv, 0, Val_int (libVer)); +@@ -53,7 +53,7 @@ ocaml_libvirt_connect_open (value namev, value unit) + virConnectPtr conn; + + NONBLOCKING (conn = virConnectOpen (name)); +- CHECK_ERROR (!conn, NULL, "virConnectOpen"); ++ CHECK_ERROR (!conn, "virConnectOpen"); + + rv = Val_connect (conn); + +@@ -69,7 +69,7 @@ ocaml_libvirt_connect_open_readonly (value namev, value unit) + virConnectPtr conn; + + NONBLOCKING (conn = virConnectOpenReadOnly (name)); +- CHECK_ERROR (!conn, NULL, "virConnectOpen"); ++ CHECK_ERROR (!conn, "virConnectOpen"); + + rv = Val_connect (conn); + +@@ -85,7 +85,7 @@ ocaml_libvirt_connect_get_version (value connv) + int r; + + NONBLOCKING (r = virConnectGetVersion (conn, &hvVer)); +- CHECK_ERROR (r == -1, conn, "virConnectGetVersion"); ++ CHECK_ERROR (r == -1, "virConnectGetVersion"); + + CAMLreturn (Val_int (hvVer)); + } +@@ -99,7 +99,7 @@ ocaml_libvirt_connect_get_max_vcpus (value connv, value typev) + int r; + + NONBLOCKING (r = virConnectGetMaxVcpus (conn, type)); +- CHECK_ERROR (r == -1, conn, "virConnectGetMaxVcpus"); ++ CHECK_ERROR (r == -1, "virConnectGetMaxVcpus"); + + CAMLreturn (Val_int (r)); + } +@@ -114,7 +114,7 @@ ocaml_libvirt_connect_get_node_info (value connv) + int r; + + NONBLOCKING (r = virNodeGetInfo (conn, &info)); +- CHECK_ERROR (r == -1, conn, "virNodeGetInfo"); ++ CHECK_ERROR (r == -1, "virNodeGetInfo"); + + rv = caml_alloc (8, 0); + v = caml_copy_string (info.model); Store_field (rv, 0, v); +@@ -138,7 +138,7 @@ ocaml_libvirt_connect_node_get_free_memory (value connv) + unsigned long long r; + + NONBLOCKING (r = virNodeGetFreeMemory (conn)); +- CHECK_ERROR (r == 0, conn, "virNodeGetFreeMemory"); ++ CHECK_ERROR (r == 0, "virNodeGetFreeMemory"); + + rv = caml_copy_int64 ((int64_t) r); + CAMLreturn (rv); +@@ -157,7 +157,7 @@ ocaml_libvirt_connect_node_get_cells_free_memory (value connv, + unsigned long long freemems[max]; + + NONBLOCKING (r = virNodeGetCellsFreeMemory (conn, freemems, start, max)); +- CHECK_ERROR (r == -1, conn, "virNodeGetCellsFreeMemory"); ++ CHECK_ERROR (r == -1, "virNodeGetCellsFreeMemory"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +@@ -179,7 +179,7 @@ ocaml_libvirt_connect_set_keep_alive(value connv, + int r; + + NONBLOCKING(r = virConnectSetKeepAlive(conn, interval, count)); +- CHECK_ERROR (r == -1, conn, "virConnectSetKeepAlive"); ++ CHECK_ERROR (r == -1, "virConnectSetKeepAlive"); + + CAMLreturn(Val_unit); + } +@@ -190,7 +190,6 @@ ocaml_libvirt_domain_get_id (value domv) + { + CAMLparam1 (domv); + virDomainPtr dom = Domain_val (domv); +- /*virConnectPtr conn = Connect_domv (domv);*/ + unsigned int r; + + NONBLOCKING (r = virDomainGetID (dom)); +@@ -208,11 +207,10 @@ ocaml_libvirt_domain_get_max_memory (value domv) + CAMLparam1 (domv); + CAMLlocal1 (rv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + unsigned long r; + + NONBLOCKING (r = virDomainGetMaxMemory (dom)); +- CHECK_ERROR (r == 0 /* [sic] */, conn, "virDomainGetMaxMemory"); ++ CHECK_ERROR (r == 0 /* [sic] */, "virDomainGetMaxMemory"); + + rv = caml_copy_int64 (r); + CAMLreturn (rv); +@@ -223,12 +221,11 @@ ocaml_libvirt_domain_set_max_memory (value domv, value memv) + { + CAMLparam2 (domv, memv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + unsigned long mem = Int64_val (memv); + int r; + + NONBLOCKING (r = virDomainSetMaxMemory (dom, mem)); +- CHECK_ERROR (r == -1, conn, "virDomainSetMaxMemory"); ++ CHECK_ERROR (r == -1, "virDomainSetMaxMemory"); + + CAMLreturn (Val_unit); + } +@@ -238,12 +235,11 @@ ocaml_libvirt_domain_set_memory (value domv, value memv) + { + CAMLparam2 (domv, memv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + unsigned long mem = Int64_val (memv); + int r; + + NONBLOCKING (r = virDomainSetMemory (dom, mem)); +- CHECK_ERROR (r == -1, conn, "virDomainSetMemory"); ++ CHECK_ERROR (r == -1, "virDomainSetMemory"); + + CAMLreturn (Val_unit); + } +@@ -254,12 +250,11 @@ ocaml_libvirt_domain_get_info (value domv) + CAMLparam1 (domv); + CAMLlocal2 (rv, v); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + virDomainInfo info; + int r; + + NONBLOCKING (r = virDomainGetInfo (dom, &info)); +- CHECK_ERROR (r == -1, conn, "virDomainGetInfo"); ++ CHECK_ERROR (r == -1, "virDomainGetInfo"); + + rv = caml_alloc (5, 0); + Store_field (rv, 0, Val_int (info.state)); // These flags are compatible. +@@ -277,12 +272,11 @@ ocaml_libvirt_domain_get_scheduler_type (value domv) + CAMLparam1 (domv); + CAMLlocal2 (rv, strv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *r; + int nparams; + + NONBLOCKING (r = virDomainGetSchedulerType (dom, &nparams)); +- CHECK_ERROR (!r, conn, "virDomainGetSchedulerType"); ++ CHECK_ERROR (!r, "virDomainGetSchedulerType"); + + rv = caml_alloc_tuple (2); + strv = caml_copy_string (r); Store_field (rv, 0, strv); +@@ -297,13 +291,12 @@ ocaml_libvirt_domain_get_scheduler_parameters (value domv, value nparamsv) + CAMLparam2 (domv, nparamsv); + CAMLlocal4 (rv, v, v2, v3); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int nparams = Int_val (nparamsv); + virSchedParameter params[nparams]; + int r, i; + + NONBLOCKING (r = virDomainGetSchedulerParameters (dom, params, &nparams)); +- CHECK_ERROR (r == -1, conn, "virDomainGetSchedulerParameters"); ++ CHECK_ERROR (r == -1, "virDomainGetSchedulerParameters"); + + rv = caml_alloc (nparams, 0); + for (i = 0; i < nparams; ++i) { +@@ -348,7 +341,6 @@ ocaml_libvirt_domain_set_scheduler_parameters (value domv, value paramsv) + CAMLparam2 (domv, paramsv); + CAMLlocal1 (v); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int nparams = Wosize_val (paramsv); + virSchedParameter params[nparams]; + int r, i; +@@ -391,7 +383,7 @@ ocaml_libvirt_domain_set_scheduler_parameters (value domv, value paramsv) + } + + NONBLOCKING (r = virDomainSetSchedulerParameters (dom, params, nparams)); +- CHECK_ERROR (r == -1, conn, "virDomainSetSchedulerParameters"); ++ CHECK_ERROR (r == -1, "virDomainSetSchedulerParameters"); + + CAMLreturn (Val_unit); + } +@@ -401,11 +393,10 @@ ocaml_libvirt_domain_set_vcpus (value domv, value nvcpusv) + { + CAMLparam2 (domv, nvcpusv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r, nvcpus = Int_val (nvcpusv); + + NONBLOCKING (r = virDomainSetVcpus (dom, nvcpus)); +- CHECK_ERROR (r == -1, conn, "virDomainSetVcpus"); ++ CHECK_ERROR (r == -1, "virDomainSetVcpus"); + + CAMLreturn (Val_unit); + } +@@ -415,14 +406,13 @@ ocaml_libvirt_domain_pin_vcpu (value domv, value vcpuv, value cpumapv) + { + CAMLparam3 (domv, vcpuv, cpumapv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int maplen = caml_string_length (cpumapv); + unsigned char *cpumap = (unsigned char *) String_val (cpumapv); + int vcpu = Int_val (vcpuv); + int r; + + NONBLOCKING (r = virDomainPinVcpu (dom, vcpu, cpumap, maplen)); +- CHECK_ERROR (r == -1, conn, "virDomainPinVcpu"); ++ CHECK_ERROR (r == -1, "virDomainPinVcpu"); + + CAMLreturn (Val_unit); + } +@@ -433,7 +423,6 @@ ocaml_libvirt_domain_get_vcpus (value domv, value maxinfov, value maplenv) + CAMLparam3 (domv, maxinfov, maplenv); + CAMLlocal5 (rv, infov, strv, v, v2); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int maxinfo = Int_val (maxinfov); + int maplen = Int_val (maplenv); + virVcpuInfo info[maxinfo]; +@@ -444,7 +433,7 @@ ocaml_libvirt_domain_get_vcpus (value domv, value maxinfov, value maplenv) + memset (cpumaps, 0, maxinfo * maplen); + + NONBLOCKING (r = virDomainGetVcpus (dom, info, maxinfo, cpumaps, maplen)); +- CHECK_ERROR (r == -1, conn, "virDomainPinVcpu"); ++ CHECK_ERROR (r == -1, "virDomainPinVcpu"); + + /* Copy the virVcpuInfo structures. */ + infov = caml_alloc (maxinfo, 0); +@@ -476,18 +465,17 @@ ocaml_libvirt_domain_get_cpu_stats (value domv) + CAMLlocal5 (cpustats, param_head, param_node, typed_param, typed_param_value); + CAMLlocal1 (v); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + virTypedParameterPtr params; + int r, cpu, ncpus, nparams, i, j, pos; + int nr_pcpus; + + /* get number of pcpus */ + NONBLOCKING (nr_pcpus = virDomainGetCPUStats(dom, NULL, 0, 0, 0, 0)); +- CHECK_ERROR (nr_pcpus < 0, conn, "virDomainGetCPUStats"); ++ CHECK_ERROR (nr_pcpus < 0, "virDomainGetCPUStats"); + + /* get percpu information */ + NONBLOCKING (nparams = virDomainGetCPUStats(dom, NULL, 0, 0, 1, 0)); +- CHECK_ERROR (nparams < 0, conn, "virDomainGetCPUStats"); ++ CHECK_ERROR (nparams < 0, "virDomainGetCPUStats"); + + if ((params = malloc(sizeof(*params) * nparams * 128)) == NULL) + caml_failwith ("virDomainGetCPUStats: malloc"); +@@ -498,7 +486,7 @@ ocaml_libvirt_domain_get_cpu_stats (value domv) + ncpus = nr_pcpus - cpu > 128 ? 128 : nr_pcpus - cpu; + + NONBLOCKING (r = virDomainGetCPUStats(dom, params, nparams, cpu, ncpus, 0)); +- CHECK_ERROR (r < 0, conn, "virDomainGetCPUStats"); ++ CHECK_ERROR (r < 0, "virDomainGetCPUStats"); + + for (i = 0; i < ncpus; i++) { + /* list of typed_param: single linked list of param_nodes */ +@@ -579,7 +567,6 @@ ocaml_libvirt_domain_migrate_native (value domv, value dconnv, value flagsv, val + CAMLxparam2 (optbandwidthv, unitv); + CAMLlocal2 (flagv, rv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + virConnectPtr dconn = Connect_val (dconnv); + int flags = 0; + const char *dname = Optstring_val (optdnamev); +@@ -601,7 +588,7 @@ ocaml_libvirt_domain_migrate_native (value domv, value dconnv, value flagsv, val + bandwidth = Int_val (Field (optbandwidthv, 0)); + + NONBLOCKING (r = virDomainMigrate (dom, dconn, flags, dname, uri, bandwidth)); +- CHECK_ERROR (!r, conn, "virDomainMigrate"); ++ CHECK_ERROR (!r, "virDomainMigrate"); + + rv = Val_domain (r, dconnv); + +@@ -622,13 +609,12 @@ ocaml_libvirt_domain_block_stats (value domv, value pathv) + CAMLparam2 (domv, pathv); + CAMLlocal2 (rv,v); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *path = String_val (pathv); + struct _virDomainBlockStats stats; + int r; + + NONBLOCKING (r = virDomainBlockStats (dom, path, &stats, sizeof stats)); +- CHECK_ERROR (r == -1, conn, "virDomainBlockStats"); ++ CHECK_ERROR (r == -1, "virDomainBlockStats"); + + rv = caml_alloc (5, 0); + v = caml_copy_int64 (stats.rd_req); Store_field (rv, 0, v); +@@ -646,13 +632,12 @@ ocaml_libvirt_domain_interface_stats (value domv, value pathv) + CAMLparam2 (domv, pathv); + CAMLlocal2 (rv,v); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *path = String_val (pathv); + struct _virDomainInterfaceStats stats; + int r; + + NONBLOCKING (r = virDomainInterfaceStats (dom, path, &stats, sizeof stats)); +- CHECK_ERROR (r == -1, conn, "virDomainInterfaceStats"); ++ CHECK_ERROR (r == -1, "virDomainInterfaceStats"); + + rv = caml_alloc (8, 0); + v = caml_copy_int64 (stats.rx_bytes); Store_field (rv, 0, v); +@@ -673,7 +658,6 @@ ocaml_libvirt_domain_block_peek_native (value domv, value pathv, value offsetv, + CAMLparam5 (domv, pathv, offsetv, sizev, bufferv); + CAMLxparam1 (boffv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + const char *path = String_val (pathv); + unsigned long long offset = Int64_val (offsetv); + size_t size = Int_val (sizev); +@@ -687,7 +671,7 @@ ocaml_libvirt_domain_block_peek_native (value domv, value pathv, value offsetv, + + /* NB. not NONBLOCKING because buffer might move (XXX) */ + r = virDomainBlockPeek (dom, path, offset, size, buffer+boff, 0); +- CHECK_ERROR (r == -1, conn, "virDomainBlockPeek"); ++ CHECK_ERROR (r == -1, "virDomainBlockPeek"); + + CAMLreturn (Val_unit); + } +@@ -706,7 +690,6 @@ ocaml_libvirt_domain_memory_peek_native (value domv, value flagsv, value offsetv + CAMLxparam1 (boffv); + CAMLlocal1 (flagv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int flags = 0; + unsigned long long offset = Int64_val (offsetv); + size_t size = Int_val (sizev); +@@ -728,7 +711,7 @@ ocaml_libvirt_domain_memory_peek_native (value domv, value flagsv, value offsetv + + /* NB. not NONBLOCKING because buffer might move (XXX) */ + r = virDomainMemoryPeek (dom, offset, size, buffer+boff, flags); +- CHECK_ERROR (r == -1, conn, "virDomainMemoryPeek"); ++ CHECK_ERROR (r == -1, "virDomainMemoryPeek"); + + CAMLreturn (Val_unit); + } +@@ -1042,7 +1025,6 @@ CAMLprim value + ocaml_libvirt_event_add_timeout (value connv, value ms, value callback_id) + { + CAMLparam3 (connv, ms, callback_id); +- virConnectPtr conn = Connect_val (connv); + void *opaque; + virFreeCallback freecb = free; + virEventTimeoutCallback cb = timeout_callback; +@@ -1055,7 +1037,7 @@ ocaml_libvirt_event_add_timeout (value connv, value ms, value callback_id) + caml_failwith ("virEventAddTimeout: malloc"); + *((long*)opaque) = Int64_val(callback_id); + NONBLOCKING(r = virEventAddTimeout(Int_val(ms), cb, opaque, freecb)); +- CHECK_ERROR(r == -1, conn, "virEventAddTimeout"); ++ CHECK_ERROR(r == -1, "virEventAddTimeout"); + + CAMLreturn(Val_int(r)); + } +@@ -1064,11 +1046,10 @@ CAMLprim value + ocaml_libvirt_event_remove_timeout (value connv, value timer_id) + { + CAMLparam2 (connv, timer_id); +- virConnectPtr conn = Connect_val (connv); + int r; + + NONBLOCKING(r = virEventRemoveTimeout(Int_val(timer_id))); +- CHECK_ERROR(r == -1, conn, "virEventRemoveTimeout"); ++ CHECK_ERROR(r == -1, "virEventRemoveTimeout"); + + CAMLreturn(Val_int(r)); + } +@@ -1146,7 +1127,7 @@ ocaml_libvirt_connect_domain_event_register_any(value connv, value domv, value c + caml_failwith ("virConnectDomainEventRegisterAny: malloc"); + *((long*)opaque) = Int64_val(callback_id); + NONBLOCKING(r = virConnectDomainEventRegisterAny(conn, dom, eventID, cb, opaque, freecb)); +- CHECK_ERROR(r == -1, conn, "virConnectDomainEventRegisterAny"); ++ CHECK_ERROR(r == -1, "virConnectDomainEventRegisterAny"); + + CAMLreturn(Val_int(r)); + } +@@ -1157,12 +1138,11 @@ ocaml_libvirt_storage_pool_get_info (value poolv) + CAMLparam1 (poolv); + CAMLlocal2 (rv, v); + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + virStoragePoolInfo info; + int r; + + NONBLOCKING (r = virStoragePoolGetInfo (pool, &info)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolGetInfo"); ++ CHECK_ERROR (r == -1, "virStoragePoolGetInfo"); + + rv = caml_alloc (4, 0); + Store_field (rv, 0, Val_int (info.state)); +@@ -1179,12 +1159,11 @@ ocaml_libvirt_storage_vol_get_info (value volv) + CAMLparam1 (volv); + CAMLlocal2 (rv, v); + virStorageVolPtr vol = Volume_val (volv); +- virConnectPtr conn = Connect_volv (volv); + virStorageVolInfo info; + int r; + + NONBLOCKING (r = virStorageVolGetInfo (vol, &info)); +- CHECK_ERROR (r == -1, conn, "virStorageVolGetInfo"); ++ CHECK_ERROR (r == -1, "virStorageVolGetInfo"); + + rv = caml_alloc (3, 0); + Store_field (rv, 0, Val_int (info.type)); +@@ -1239,6 +1218,12 @@ ocaml_libvirt_virterror_reset_last_conn_error (value connv) + + /*----------------------------------------------------------------------*/ + ++static void ++ignore_errors (void *user_data, virErrorPtr error) ++{ ++ /* do nothing */ ++} ++ + /* Initialise the library. */ + CAMLprim value + ocaml_libvirt_init (value unit) +@@ -1247,8 +1232,9 @@ ocaml_libvirt_init (value unit) + CAMLlocal1 (rv); + int r; + ++ virSetErrorFunc (NULL, ignore_errors); + r = virInitialize (); +- CHECK_ERROR (r == -1, NULL, "virInitialize"); ++ CHECK_ERROR (r == -1, "virInitialize"); + + CAMLreturn (Val_unit); + } +diff --git a/libvirt/libvirt_c_prologue.c b/libvirt/libvirt_c_prologue.c +index 7d9c0f5..bf972e9 100644 +--- a/libvirt/libvirt_c_prologue.c ++++ b/libvirt/libvirt_c_prologue.c +@@ -24,7 +24,7 @@ static char *Optstring_val (value strv); + typedef value (*Val_ptr_t) (void *); + static value Val_opt (void *ptr, Val_ptr_t Val_ptr); + /*static value option_default (value option, value deflt);*/ +-static void _raise_virterror (virConnectPtr conn, const char *fn) Noreturn; ++static void _raise_virterror (const char *fn) Noreturn; + static void not_supported (const char *fn) Noreturn; + static value Val_virterror (virErrorPtr err); + +@@ -43,8 +43,8 @@ static value Val_virterror (virErrorPtr err); + /* Check error condition from a libvirt function, and automatically raise + * an exception if one is found. + */ +-#define CHECK_ERROR(cond, conn, fn) \ +- do { if (cond) _raise_virterror (conn, fn); } while (0) ++#define CHECK_ERROR(cond, fn) \ ++ do { if (cond) _raise_virterror (fn); } while (0) + + /*----------------------------------------------------------------------*/ + +-- +2.3.1 + |