Blame SOURCES/0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch

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