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

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