From 05b7cd94c28ec72a45da3c7f48d957c8a63d1a8c Mon Sep 17 00:00:00 2001 From: chenholmes Date: Thu, 27 Feb 2020 15:55:37 +0800 Subject: [PATCH] init --- ...Add-a-binding-for-virDomainCreateXML.patch | 213 ++ ...Remove-unused-not_supported-function.patch | 57 + ...to-stderr-and-use-thread-local-virEr.patch | 1864 +++++++++++++++++ ...-int64_t-instead-of-OCaml-defined-an.patch | 35 + 0001-Use-g-warn-error.patch | 78 + ...-Use-safe-string-and-fix-the-library.patch | 76 + ...r-checking-return-from-virInitialize.patch | 32 + 0002-Update-dependencies.patch | 44 + ...r-virConnectGetAllDomainStats-RHBZ-1.patch | 393 ++++ ...ore-stats-in-the-get_all_domain_stat.patch | 42 + ...f-virConnectGetAllDomainStats-to-ret.patch | 127 ++ ocaml-libvirt-0.6.1.4.tar.gz | Bin 0 -> 136023 bytes ocaml-libvirt.spec | 84 + 13 files changed, 3045 insertions(+) create mode 100644 0001-Add-a-binding-for-virDomainCreateXML.patch create mode 100644 0001-Remove-unused-not_supported-function.patch create mode 100644 0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch create mode 100644 0001-Use-C99-standard-int64_t-instead-of-OCaml-defined-an.patch create mode 100644 0001-Use-g-warn-error.patch create mode 100644 0001-Use-safe-string-and-fix-the-library.patch create mode 100644 0002-Don-t-bother-checking-return-from-virInitialize.patch create mode 100644 0002-Update-dependencies.patch create mode 100644 0003-Add-a-binding-for-virConnectGetAllDomainStats-RHBZ-1.patch create mode 100644 0004-examples-Print-more-stats-in-the-get_all_domain_stat.patch create mode 100644 0005-Change-binding-of-virConnectGetAllDomainStats-to-ret.patch create mode 100644 ocaml-libvirt-0.6.1.4.tar.gz create mode 100644 ocaml-libvirt.spec diff --git a/0001-Add-a-binding-for-virDomainCreateXML.patch b/0001-Add-a-binding-for-virDomainCreateXML.patch new file mode 100644 index 0000000..a25507b --- /dev/null +++ b/0001-Add-a-binding-for-virDomainCreateXML.patch @@ -0,0 +1,213 @@ +From 7483c7454538584a3dbe4582096f058e6e877df6 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Fri, 6 Mar 2015 15:35:46 +0000 +Subject: [PATCH] Add a binding for virDomainCreateXML. + +This is more modern than the ancient virDomainCreateLinux API, +and crucially allows you to pass flags such as AUTODESTROY. +--- + configure.ac | 2 +- + libvirt/generator.pl | 23 +++++++++++++++++++++-- + libvirt/libvirt.ml | 19 ++++++++++++++++++- + libvirt/libvirt.mli | 13 +++++++++++-- + libvirt/libvirt_c.c | 25 ++++++++++++++++++++++++- + 5 files changed, 75 insertions(+), 7 deletions(-) + +diff --git a/configure.ac b/configure.ac +index b7544b4..a719fb3 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -1,5 +1,5 @@ + # ocaml-libvirt +-# Copyright (C) 2007-2008 Red Hat Inc., Richard W.M. Jones ++# Copyright (C) 2007-2015 Red Hat Inc., Richard W.M. Jones + # + # This library is free software; you can redistribute it and/or + # modify it under the terms of the GNU Lesser General Public +diff --git a/libvirt/generator.pl b/libvirt/generator.pl +index 8229ad1..421592b 100755 +--- a/libvirt/generator.pl ++++ b/libvirt/generator.pl +@@ -1,7 +1,7 @@ + #!/usr/bin/perl -w + # + # OCaml bindings for libvirt. +-# (C) Copyright 2007-2008 Richard W.M. Jones, Red Hat Inc. ++# (C) Copyright 2007-2015 Richard W.M. Jones, Red Hat Inc. + # http://libvirt.org/ + # + # This library is free software; you can redistribute it and/or +@@ -63,6 +63,7 @@ my @functions = ( + sig => "conn, int : unit" }, + + { name => "virDomainCreateLinux", sig => "conn, string, 0U : dom" }, ++ { name => "virDomainCreateXML", sig => "conn, string, unsigned : dom" }, + { name => "virDomainFree", sig => "dom : free" }, + { name => "virDomainDestroy", sig => "dom : free" }, + { name => "virDomainLookupByName", sig => "conn, string : dom" }, +@@ -198,7 +199,7 @@ print F <<'END'; + */ + + /* OCaml bindings for libvirt. +- * (C) Copyright 2007-2008 Richard W.M. Jones, Red Hat Inc. ++ * (C) Copyright 2007-2015 Richard W.M. Jones, Red Hat Inc. + * http://libvirt.org/ + * + * This library is free software; you can redistribute it and/or +@@ -310,6 +311,8 @@ sub gen_arg_names + ( "$1v", "strv" ) + } elsif ($sig =~ /^(\w+), string, 0U? : (\w+)$/) { + ( "$1v", "strv" ) ++ } elsif ($sig =~ /^(\w+), string, unsigned : (\w+)$/) { ++ ( "$1v", "strv", "uv" ) + } elsif ($sig =~ /^(\w+), u?int : (\w+)$/) { + ( "$1v", "iv" ) + } elsif ($sig =~ /^(\w+), uuid : (\w+)$/) { +@@ -632,6 +635,22 @@ sub gen_c_code + + CAMLreturn (rv); + " ++ } elsif ($sig =~ /^(\w+), string, unsigned : (\w+)$/) { ++ my $c_ret_type = short_name_to_c_type ($2); ++ "\ ++ CAMLlocal1 (rv); ++ " . gen_unpack_args ($1) . " ++ char *str = String_val (strv); ++ unsigned int u = Int_val (uv); ++ $c_ret_type r; ++ ++ NONBLOCKING (r = $c_name ($1, str, u)); ++ CHECK_ERROR (!r, conn, \"$c_name\"); ++ ++ " . gen_pack_result ($2) . " ++ ++ CAMLreturn (rv); ++" + } elsif ($sig =~ /^(\w+), (u?)int : unit$/) { + my $unsigned = $2 eq "u" ? "unsigned " : ""; + "\ +diff --git a/libvirt/libvirt.ml b/libvirt/libvirt.ml +index 9c9368a..1be023d 100644 +--- a/libvirt/libvirt.ml ++++ b/libvirt/libvirt.ml +@@ -1,5 +1,5 @@ + (* OCaml bindings for libvirt. +- (C) Copyright 2007 Richard W.M. Jones, Red Hat Inc. ++ (C) Copyright 2007-2015 Richard W.M. Jones, Red Hat Inc. + http://libvirt.org/ + + This library is free software; you can redistribute it and/or +@@ -337,6 +337,20 @@ struct + cpu : int; + } + ++ type domain_create_flag = ++ | START_PAUSED ++ | START_AUTODESTROY ++ | START_BYPASS_CACHE ++ | START_FORCE_BOOT ++ | START_VALIDATE ++ let rec int_of_domain_create_flags = function ++ | [] -> 0 ++ | START_PAUSED :: flags -> 1 lor int_of_domain_create_flags flags ++ | START_AUTODESTROY :: flags -> 2 lor int_of_domain_create_flags flags ++ | START_BYPASS_CACHE :: flags -> 4 lor int_of_domain_create_flags flags ++ | START_FORCE_BOOT :: flags -> 8 lor int_of_domain_create_flags flags ++ | START_VALIDATE :: flags -> 16 lor int_of_domain_create_flags flags ++ + type sched_param = string * sched_param_value + and sched_param_value = + | SchedFieldInt32 of int32 | SchedFieldUInt32 of int32 +@@ -385,6 +399,9 @@ struct + let max_peek _ = 65536 + + external create_linux : [>`W] Connect.t -> xml -> rw t = "ocaml_libvirt_domain_create_linux" ++ external _create_xml : [>`W] Connect.t -> xml -> int -> rw t = "ocaml_libvirt_domain_create_xml" ++ let create_xml conn xml flags = ++ _create_xml conn xml (int_of_domain_create_flags flags) + external lookup_by_id : 'a Connect.t -> int -> 'a t = "ocaml_libvirt_domain_lookup_by_id" + external lookup_by_uuid : 'a Connect.t -> uuid -> 'a t = "ocaml_libvirt_domain_lookup_by_uuid" + external lookup_by_uuid_string : 'a Connect.t -> string -> 'a t = "ocaml_libvirt_domain_lookup_by_uuid_string" +diff --git a/libvirt/libvirt.mli b/libvirt/libvirt.mli +index 36cd113..8cfcae2 100644 +--- a/libvirt/libvirt.mli ++++ b/libvirt/libvirt.mli +@@ -1,5 +1,5 @@ + (** OCaml bindings for libvirt. *) +-(* (C) Copyright 2007 Richard W.M. Jones, Red Hat Inc. ++(* (C) Copyright 2007-2015 Richard W.M. Jones, Red Hat Inc. + http://libvirt.org/ + + This library is free software; you can redistribute it and/or +@@ -430,6 +430,13 @@ sig + cpu : int; (** real CPU number, -1 if offline *) + } + ++ type domain_create_flag = ++ | START_PAUSED (** Launch guest in paused state *) ++ | START_AUTODESTROY (** Automatically kill guest on close *) ++ | START_BYPASS_CACHE (** Avoid filesystem cache pollution *) ++ | START_FORCE_BOOT (** Discard any managed save *) ++ | START_VALIDATE (** Validate XML against schema *) ++ + type sched_param = string * sched_param_value + and sched_param_value = + | SchedFieldInt32 of int32 | SchedFieldUInt32 of int32 +@@ -478,8 +485,10 @@ sig + + val create_linux : [>`W] Connect.t -> xml -> rw t + (** Create a new guest domain (not necessarily a Linux one) +- from the given XML. ++ from the given XML. Use {!create_xml} instead. + *) ++ val create_xml : [>`W] Connect.t -> xml -> domain_create_flag list -> rw t ++ (** Create a new guest domain from the given XML. *) + val lookup_by_id : 'a Connect.t -> int -> 'a t + (** Lookup a domain by ID. *) + val lookup_by_uuid : 'a Connect.t -> uuid -> 'a t +diff --git a/libvirt/libvirt_c.c b/libvirt/libvirt_c.c +index 71e6f61..6e56682 100644 +--- a/libvirt/libvirt_c.c ++++ b/libvirt/libvirt_c.c +@@ -6,7 +6,7 @@ + */ + + /* OCaml bindings for libvirt. +- * (C) Copyright 2007-2008 Richard W.M. Jones, Red Hat Inc. ++ * (C) Copyright 2007-2015 Richard W.M. Jones, Red Hat Inc. + * http://libvirt.org/ + * + * This library is free software; you can redistribute it and/or +@@ -525,6 +525,29 @@ ocaml_libvirt_domain_create_linux (value connv, value strv) + CAMLreturn (rv); + } + ++/* Automatically generated binding for virDomainCreateXML. ++ * In generator.pl this function has signature "conn, string, unsigned : dom". ++ */ ++ ++CAMLprim value ++ocaml_libvirt_domain_create_xml (value connv, value strv, value uv) ++{ ++ CAMLparam3 (connv, strv, uv); ++ ++ CAMLlocal1 (rv); ++ virConnectPtr conn = Connect_val (connv); ++ char *str = String_val (strv); ++ unsigned int u = Int_val (uv); ++ virDomainPtr r; ++ ++ NONBLOCKING (r = virDomainCreateXML (conn, str, u)); ++ CHECK_ERROR (!r, conn, "virDomainCreateXML"); ++ ++ rv = Val_domain (r, connv); ++ ++ CAMLreturn (rv); ++} ++ + /* Automatically generated binding for virDomainFree. + * In generator.pl this function has signature "dom : free". + */ +-- +2.3.1 + diff --git a/0001-Remove-unused-not_supported-function.patch b/0001-Remove-unused-not_supported-function.patch new file mode 100644 index 0000000..851385c --- /dev/null +++ b/0001-Remove-unused-not_supported-function.patch @@ -0,0 +1,57 @@ +From 8853f5a49587f00a7d2a5c8c7e52480a16bbdb02 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Fri, 5 Feb 2016 16:28:34 +0000 +Subject: [PATCH] Remove unused 'not_supported' function. + +Found by compiling under GCC 6. The warning was: + +In file included from libvirt_c.c:2058:0: +libvirt_c_epilogue.c:89:1: error: 'not_supported' defined but not used [-Werror=unused-function] + not_supported (const char *fn) + ^~~~~~~~~~~~~ +--- + libvirt/libvirt_c_epilogue.c | 15 --------------- + libvirt/libvirt_c_prologue.c | 1 - + 2 files changed, 16 deletions(-) + +diff --git a/libvirt/libvirt_c_epilogue.c b/libvirt/libvirt_c_epilogue.c +index 4972e50..fa592c9 100644 +--- a/libvirt/libvirt_c_epilogue.c ++++ b/libvirt/libvirt_c_epilogue.c +@@ -84,21 +84,6 @@ _raise_virterror (const char *fn) + (void) caml__frame; + } + +-/* Raise an error if a function is not supported. */ +-static void +-not_supported (const char *fn) +-{ +- CAMLparam0 (); +- CAMLlocal1 (fnv); +- +- fnv = caml_copy_string (fn); +- caml_raise_with_arg (*caml_named_value ("ocaml_libvirt_not_supported"), fnv); +- +- /*NOTREACHED*/ +- /* Suppresses a compiler warning. */ +- (void) caml__frame; +-} +- + /* Convert the virErrorNumber, virErrorDomain and virErrorLevel enums + * into values (longs because they are variants in OCaml). + * +diff --git a/libvirt/libvirt_c_prologue.c b/libvirt/libvirt_c_prologue.c +index bf972e9..710c0d6 100644 +--- a/libvirt/libvirt_c_prologue.c ++++ b/libvirt/libvirt_c_prologue.c +@@ -25,7 +25,6 @@ typedef value (*Val_ptr_t) (void *); + static value Val_opt (void *ptr, Val_ptr_t Val_ptr); + /*static value option_default (value option, value deflt);*/ + static void _raise_virterror (const char *fn) Noreturn; +-static void not_supported (const char *fn) Noreturn; + static value Val_virterror (virErrorPtr err); + + /* Use this around synchronous libvirt API calls to release the OCaml +-- +2.5.0 + diff --git a/0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch b/0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch new file mode 100644 index 0000000..f365534 --- /dev/null +++ b/0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch @@ -0,0 +1,1864 @@ +From 68fae1ec3de46fd9eec88fb7c1894ea7ed85ccc9 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 17 Mar 2015 12:51:50 +0000 +Subject: [PATCH 1/2] Suppress errors to stderr and use thread-local + virErrorPtr + +This allows us to capture errors that happen during virConnectOpen, +without spewing error messages on stderr. + +The patch is rather large, only because we don't need to pass the +virConnectPtr argument to CHECK_ERROR/_raise_virterror any longer. +--- + libvirt/generator.pl | 66 ++++++------ + libvirt/libvirt_c.c | 241 +++++++++++++++++-------------------------- + libvirt/libvirt_c_epilogue.c | 4 +- + libvirt/libvirt_c_oneoffs.c | 94 +++++++---------- + libvirt/libvirt_c_prologue.c | 6 +- + 5 files changed, 169 insertions(+), 242 deletions(-) + +diff --git a/libvirt/generator.pl b/libvirt/generator.pl +index 421592b..34801ba 100755 +--- a/libvirt/generator.pl ++++ b/libvirt/generator.pl +@@ -343,17 +343,13 @@ sub gen_unpack_args + if ($_ eq "conn") { + "virConnectPtr conn = Connect_val (connv);" + } elsif ($_ eq "dom") { +- "virDomainPtr dom = Domain_val (domv);\n". +- " virConnectPtr conn = Connect_domv (domv);" ++ "virDomainPtr dom = Domain_val (domv);" + } elsif ($_ eq "net") { +- "virNetworkPtr net = Network_val (netv);\n". +- " virConnectPtr conn = Connect_netv (netv);" ++ "virNetworkPtr net = Network_val (netv);" + } elsif ($_ eq "pool") { +- "virStoragePoolPtr pool = Pool_val (poolv);\n". +- " virConnectPtr conn = Connect_polv (poolv);" ++ "virStoragePoolPtr pool = Pool_val (poolv);" + } elsif ($_ eq "vol") { +- "virStorageVolPtr vol = Volume_val (volv);\n". +- " virConnectPtr conn = Connect_volv (volv);" ++ "virStorageVolPtr vol = Volume_val (volv);" + } else { + die "unknown short name $_" + } +@@ -402,7 +398,7 @@ sub gen_c_code + char *r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + rv = caml_copy_string (r); + free (r); +@@ -415,7 +411,7 @@ sub gen_c_code + const char *r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + rv = caml_copy_string (r); + CAMLreturn (rv); +@@ -426,7 +422,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_int (r)); + " +@@ -438,7 +434,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, uuid)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + /* UUIDs are byte arrays with a fixed length. */ + rv = caml_alloc_string (VIR_UUID_BUFLEN); +@@ -453,7 +449,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, uuid)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + rv = caml_copy_string (uuid); + CAMLreturn (rv); +@@ -464,7 +460,7 @@ sub gen_c_code + int r, b; + + NONBLOCKING (r = $c_name ($1, &b)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (b ? Val_true : Val_false); + " +@@ -476,7 +472,7 @@ sub gen_c_code + b = bv == Val_true ? 1 : 0; + + NONBLOCKING (r = $c_name ($1, b)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -498,7 +494,7 @@ sub gen_c_code + } + + NONBLOCKING (r = $c_name (conn, ids, i)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) +@@ -525,7 +521,7 @@ sub gen_c_code + } + + NONBLOCKING (r = $c_name ($1, names, i)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +@@ -543,7 +539,7 @@ sub gen_c_code + char *r; + + NONBLOCKING (r = $c_name ($1, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + rv = caml_copy_string (r); + free (r); +@@ -555,7 +551,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, 0)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -565,7 +561,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -575,7 +571,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + /* So that we don't double-free in the finalizer: */ + " . gen_free_arg ($1) . " +@@ -589,7 +585,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, str)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -601,7 +597,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, str, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -614,7 +610,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, str)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -629,7 +625,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, str, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -645,7 +641,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, str, u)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -659,7 +655,7 @@ sub gen_c_code + int r; + + NONBLOCKING (r = $c_name ($1, i)); +- CHECK_ERROR (r == -1, conn, \"$c_name\"); ++ CHECK_ERROR (r == -1, \"$c_name\"); + + CAMLreturn (Val_unit); + " +@@ -673,7 +669,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, i)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($3) . " + +@@ -688,7 +684,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, uuid)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -702,7 +698,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -716,7 +712,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + " . gen_pack_result ($2) . " + +@@ -731,7 +727,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, str)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + connv = Field ($3v, 1); + " . gen_pack_result ($2) . " +@@ -747,7 +743,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, str, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + connv = Field ($3v, 1); + " . gen_pack_result ($2) . " +@@ -762,7 +758,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1, 0)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + connv = Field ($3v, 1); + " . gen_pack_result ($2) . " +@@ -777,7 +773,7 @@ sub gen_c_code + $c_ret_type r; + + NONBLOCKING (r = $c_name ($1)); +- CHECK_ERROR (!r, conn, \"$c_name\"); ++ CHECK_ERROR (!r, \"$c_name\"); + + connv = Field ($3v, 1); + " . gen_pack_result ($2) . " +diff --git a/libvirt/libvirt_c.c b/libvirt/libvirt_c.c +index 6e56682..8d51944 100644 +--- a/libvirt/libvirt_c.c ++++ b/libvirt/libvirt_c.c +@@ -61,7 +61,7 @@ ocaml_libvirt_connect_close (value connv) + int r; + + NONBLOCKING (r = virConnectClose (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectClose"); ++ CHECK_ERROR (r == -1, "virConnectClose"); + + /* So that we don't double-free in the finalizer: */ + Connect_val (connv) = NULL; +@@ -83,7 +83,7 @@ ocaml_libvirt_connect_get_hostname (value connv) + char *r; + + NONBLOCKING (r = virConnectGetHostname (conn)); +- CHECK_ERROR (!r, conn, "virConnectGetHostname"); ++ CHECK_ERROR (!r, "virConnectGetHostname"); + + rv = caml_copy_string (r); + free (r); +@@ -104,7 +104,7 @@ ocaml_libvirt_connect_get_uri (value connv) + char *r; + + NONBLOCKING (r = virConnectGetURI (conn)); +- CHECK_ERROR (!r, conn, "virConnectGetURI"); ++ CHECK_ERROR (!r, "virConnectGetURI"); + + rv = caml_copy_string (r); + free (r); +@@ -125,7 +125,7 @@ ocaml_libvirt_connect_get_type (value connv) + const char *r; + + NONBLOCKING (r = virConnectGetType (conn)); +- CHECK_ERROR (!r, conn, "virConnectGetType"); ++ CHECK_ERROR (!r, "virConnectGetType"); + + rv = caml_copy_string (r); + CAMLreturn (rv); +@@ -144,7 +144,7 @@ ocaml_libvirt_connect_num_of_domains (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfDomains (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfDomains"); ++ CHECK_ERROR (r == -1, "virConnectNumOfDomains"); + + CAMLreturn (Val_int (r)); + } +@@ -174,7 +174,7 @@ ocaml_libvirt_connect_list_domains (value connv, value iv) + } + + NONBLOCKING (r = virConnectListDomains (conn, ids, i)); +- CHECK_ERROR (r == -1, conn, "virConnectListDomains"); ++ CHECK_ERROR (r == -1, "virConnectListDomains"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) +@@ -196,7 +196,7 @@ ocaml_libvirt_connect_num_of_defined_domains (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfDefinedDomains (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedDomains"); ++ CHECK_ERROR (r == -1, "virConnectNumOfDefinedDomains"); + + CAMLreturn (Val_int (r)); + } +@@ -227,7 +227,7 @@ ocaml_libvirt_connect_list_defined_domains (value connv, value iv) + } + + NONBLOCKING (r = virConnectListDefinedDomains (conn, names, i)); +- CHECK_ERROR (r == -1, conn, "virConnectListDefinedDomains"); ++ CHECK_ERROR (r == -1, "virConnectListDefinedDomains"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +@@ -252,7 +252,7 @@ ocaml_libvirt_connect_num_of_networks (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfNetworks (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfNetworks"); ++ CHECK_ERROR (r == -1, "virConnectNumOfNetworks"); + + CAMLreturn (Val_int (r)); + } +@@ -283,7 +283,7 @@ ocaml_libvirt_connect_list_networks (value connv, value iv) + } + + NONBLOCKING (r = virConnectListNetworks (conn, names, i)); +- CHECK_ERROR (r == -1, conn, "virConnectListNetworks"); ++ CHECK_ERROR (r == -1, "virConnectListNetworks"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +@@ -308,7 +308,7 @@ ocaml_libvirt_connect_num_of_defined_networks (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfDefinedNetworks (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedNetworks"); ++ CHECK_ERROR (r == -1, "virConnectNumOfDefinedNetworks"); + + CAMLreturn (Val_int (r)); + } +@@ -339,7 +339,7 @@ ocaml_libvirt_connect_list_defined_networks (value connv, value iv) + } + + NONBLOCKING (r = virConnectListDefinedNetworks (conn, names, i)); +- CHECK_ERROR (r == -1, conn, "virConnectListDefinedNetworks"); ++ CHECK_ERROR (r == -1, "virConnectListDefinedNetworks"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +@@ -364,7 +364,7 @@ ocaml_libvirt_connect_num_of_storage_pools (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfStoragePools (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfStoragePools"); ++ CHECK_ERROR (r == -1, "virConnectNumOfStoragePools"); + + CAMLreturn (Val_int (r)); + } +@@ -395,7 +395,7 @@ ocaml_libvirt_connect_list_storage_pools (value connv, value iv) + } + + NONBLOCKING (r = virConnectListStoragePools (conn, names, i)); +- CHECK_ERROR (r == -1, conn, "virConnectListStoragePools"); ++ CHECK_ERROR (r == -1, "virConnectListStoragePools"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +@@ -420,7 +420,7 @@ ocaml_libvirt_connect_num_of_defined_storage_pools (value connv) + int r; + + NONBLOCKING (r = virConnectNumOfDefinedStoragePools (conn)); +- CHECK_ERROR (r == -1, conn, "virConnectNumOfDefinedStoragePools"); ++ CHECK_ERROR (r == -1, "virConnectNumOfDefinedStoragePools"); + + CAMLreturn (Val_int (r)); + } +@@ -451,7 +451,7 @@ ocaml_libvirt_connect_list_defined_storage_pools (value connv, value iv) + } + + NONBLOCKING (r = virConnectListDefinedStoragePools (conn, names, i)); +- CHECK_ERROR (r == -1, conn, "virConnectListDefinedStoragePools"); ++ CHECK_ERROR (r == -1, "virConnectListDefinedStoragePools"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +@@ -477,7 +477,7 @@ ocaml_libvirt_connect_get_capabilities (value connv) + char *r; + + NONBLOCKING (r = virConnectGetCapabilities (conn)); +- CHECK_ERROR (!r, conn, "virConnectGetCapabilities"); ++ CHECK_ERROR (!r, "virConnectGetCapabilities"); + + rv = caml_copy_string (r); + free (r); +@@ -498,7 +498,7 @@ ocaml_libvirt_connect_domain_event_deregister_any (value connv, value iv) + int r; + + NONBLOCKING (r = virConnectDomainEventDeregisterAny (conn, i)); +- CHECK_ERROR (r == -1, conn, "virConnectDomainEventDeregisterAny"); ++ CHECK_ERROR (r == -1, "virConnectDomainEventDeregisterAny"); + + CAMLreturn (Val_unit); + } +@@ -518,7 +518,7 @@ ocaml_libvirt_domain_create_linux (value connv, value strv) + virDomainPtr r; + + NONBLOCKING (r = virDomainCreateLinux (conn, str, 0)); +- CHECK_ERROR (!r, conn, "virDomainCreateLinux"); ++ CHECK_ERROR (!r, "virDomainCreateLinux"); + + rv = Val_domain (r, connv); + +@@ -541,7 +541,7 @@ ocaml_libvirt_domain_create_xml (value connv, value strv, value uv) + virDomainPtr r; + + NONBLOCKING (r = virDomainCreateXML (conn, str, u)); +- CHECK_ERROR (!r, conn, "virDomainCreateXML"); ++ CHECK_ERROR (!r, "virDomainCreateXML"); + + rv = Val_domain (r, connv); + +@@ -558,11 +558,10 @@ ocaml_libvirt_domain_free (value domv) + CAMLparam1 (domv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r; + + NONBLOCKING (r = virDomainFree (dom)); +- CHECK_ERROR (r == -1, conn, "virDomainFree"); ++ CHECK_ERROR (r == -1, "virDomainFree"); + + /* So that we don't double-free in the finalizer: */ + Domain_val (domv) = NULL; +@@ -580,11 +579,10 @@ ocaml_libvirt_domain_destroy (value domv) + CAMLparam1 (domv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r; + + NONBLOCKING (r = virDomainDestroy (dom)); +- CHECK_ERROR (r == -1, conn, "virDomainDestroy"); ++ CHECK_ERROR (r == -1, "virDomainDestroy"); + + /* So that we don't double-free in the finalizer: */ + Domain_val (domv) = NULL; +@@ -607,7 +605,7 @@ ocaml_libvirt_domain_lookup_by_name (value connv, value strv) + virDomainPtr r; + + NONBLOCKING (r = virDomainLookupByName (conn, str)); +- CHECK_ERROR (!r, conn, "virDomainLookupByName"); ++ CHECK_ERROR (!r, "virDomainLookupByName"); + + rv = Val_domain (r, connv); + +@@ -629,7 +627,7 @@ ocaml_libvirt_domain_lookup_by_id (value connv, value iv) + virDomainPtr r; + + NONBLOCKING (r = virDomainLookupByID (conn, i)); +- CHECK_ERROR (!r, conn, "virDomainLookupByID"); ++ CHECK_ERROR (!r, "virDomainLookupByID"); + + rv = Val_domain (r, connv); + +@@ -651,7 +649,7 @@ ocaml_libvirt_domain_lookup_by_uuid (value connv, value uuidv) + virDomainPtr r; + + NONBLOCKING (r = virDomainLookupByUUID (conn, uuid)); +- CHECK_ERROR (!r, conn, "virDomainLookupByUUID"); ++ CHECK_ERROR (!r, "virDomainLookupByUUID"); + + rv = Val_domain (r, connv); + +@@ -673,7 +671,7 @@ ocaml_libvirt_domain_lookup_by_uuid_string (value connv, value strv) + virDomainPtr r; + + NONBLOCKING (r = virDomainLookupByUUIDString (conn, str)); +- CHECK_ERROR (!r, conn, "virDomainLookupByUUIDString"); ++ CHECK_ERROR (!r, "virDomainLookupByUUIDString"); + + rv = Val_domain (r, connv); + +@@ -691,11 +689,10 @@ ocaml_libvirt_domain_get_name (value domv) + + CAMLlocal1 (rv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + const char *r; + + NONBLOCKING (r = virDomainGetName (dom)); +- CHECK_ERROR (!r, conn, "virDomainGetName"); ++ CHECK_ERROR (!r, "virDomainGetName"); + + rv = caml_copy_string (r); + CAMLreturn (rv); +@@ -712,11 +709,10 @@ ocaml_libvirt_domain_get_os_type (value domv) + + CAMLlocal1 (rv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *r; + + NONBLOCKING (r = virDomainGetOSType (dom)); +- CHECK_ERROR (!r, conn, "virDomainGetOSType"); ++ CHECK_ERROR (!r, "virDomainGetOSType"); + + rv = caml_copy_string (r); + free (r); +@@ -734,11 +730,10 @@ ocaml_libvirt_domain_get_xml_desc (value domv) + + CAMLlocal1 (rv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *r; + + NONBLOCKING (r = virDomainGetXMLDesc (dom, 0)); +- CHECK_ERROR (!r, conn, "virDomainGetXMLDesc"); ++ CHECK_ERROR (!r, "virDomainGetXMLDesc"); + + rv = caml_copy_string (r); + free (r); +@@ -756,12 +751,11 @@ ocaml_libvirt_domain_get_uuid (value domv) + + CAMLlocal1 (rv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + unsigned char uuid[VIR_UUID_BUFLEN]; + int r; + + NONBLOCKING (r = virDomainGetUUID (dom, uuid)); +- CHECK_ERROR (r == -1, conn, "virDomainGetUUID"); ++ CHECK_ERROR (r == -1, "virDomainGetUUID"); + + /* UUIDs are byte arrays with a fixed length. */ + rv = caml_alloc_string (VIR_UUID_BUFLEN); +@@ -780,12 +774,11 @@ ocaml_libvirt_domain_get_uuid_string (value domv) + + CAMLlocal1 (rv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char uuid[VIR_UUID_STRING_BUFLEN]; + int r; + + NONBLOCKING (r = virDomainGetUUIDString (dom, uuid)); +- CHECK_ERROR (r == -1, conn, "virDomainGetUUIDString"); ++ CHECK_ERROR (r == -1, "virDomainGetUUIDString"); + + rv = caml_copy_string (uuid); + CAMLreturn (rv); +@@ -801,11 +794,10 @@ ocaml_libvirt_domain_get_max_vcpus (value domv) + CAMLparam1 (domv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r; + + NONBLOCKING (r = virDomainGetMaxVcpus (dom)); +- CHECK_ERROR (r == -1, conn, "virDomainGetMaxVcpus"); ++ CHECK_ERROR (r == -1, "virDomainGetMaxVcpus"); + + CAMLreturn (Val_int (r)); + } +@@ -820,12 +812,11 @@ ocaml_libvirt_domain_save (value domv, value strv) + CAMLparam2 (domv, strv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *str = String_val (strv); + int r; + + NONBLOCKING (r = virDomainSave (dom, str)); +- CHECK_ERROR (r == -1, conn, "virDomainSave"); ++ CHECK_ERROR (r == -1, "virDomainSave"); + + CAMLreturn (Val_unit); + } +@@ -844,7 +835,7 @@ ocaml_libvirt_domain_restore (value connv, value strv) + int r; + + NONBLOCKING (r = virDomainRestore (conn, str)); +- CHECK_ERROR (r == -1, conn, "virDomainRestore"); ++ CHECK_ERROR (r == -1, "virDomainRestore"); + + CAMLreturn (Val_unit); + } +@@ -860,12 +851,11 @@ ocaml_libvirt_domain_core_dump (value domv, value strv) + + CAMLlocal1 (rv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *str = String_val (strv); + int r; + + NONBLOCKING (r = virDomainCoreDump (dom, str, 0)); +- CHECK_ERROR (!r, conn, "virDomainCoreDump"); ++ CHECK_ERROR (!r, "virDomainCoreDump"); + + CAMLreturn (Val_unit); + } +@@ -880,11 +870,10 @@ ocaml_libvirt_domain_suspend (value domv) + CAMLparam1 (domv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r; + + NONBLOCKING (r = virDomainSuspend (dom)); +- CHECK_ERROR (r == -1, conn, "virDomainSuspend"); ++ CHECK_ERROR (r == -1, "virDomainSuspend"); + + CAMLreturn (Val_unit); + } +@@ -899,11 +888,10 @@ ocaml_libvirt_domain_resume (value domv) + CAMLparam1 (domv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r; + + NONBLOCKING (r = virDomainResume (dom)); +- CHECK_ERROR (r == -1, conn, "virDomainResume"); ++ CHECK_ERROR (r == -1, "virDomainResume"); + + CAMLreturn (Val_unit); + } +@@ -918,11 +906,10 @@ ocaml_libvirt_domain_shutdown (value domv) + CAMLparam1 (domv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r; + + NONBLOCKING (r = virDomainShutdown (dom)); +- CHECK_ERROR (r == -1, conn, "virDomainShutdown"); ++ CHECK_ERROR (r == -1, "virDomainShutdown"); + + CAMLreturn (Val_unit); + } +@@ -937,11 +924,10 @@ ocaml_libvirt_domain_reboot (value domv) + CAMLparam1 (domv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r; + + NONBLOCKING (r = virDomainReboot (dom, 0)); +- CHECK_ERROR (r == -1, conn, "virDomainReboot"); ++ CHECK_ERROR (r == -1, "virDomainReboot"); + + CAMLreturn (Val_unit); + } +@@ -961,7 +947,7 @@ ocaml_libvirt_domain_define_xml (value connv, value strv) + virDomainPtr r; + + NONBLOCKING (r = virDomainDefineXML (conn, str)); +- CHECK_ERROR (!r, conn, "virDomainDefineXML"); ++ CHECK_ERROR (!r, "virDomainDefineXML"); + + rv = Val_domain (r, connv); + +@@ -978,11 +964,10 @@ ocaml_libvirt_domain_undefine (value domv) + CAMLparam1 (domv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r; + + NONBLOCKING (r = virDomainUndefine (dom)); +- CHECK_ERROR (r == -1, conn, "virDomainUndefine"); ++ CHECK_ERROR (r == -1, "virDomainUndefine"); + + CAMLreturn (Val_unit); + } +@@ -997,11 +982,10 @@ ocaml_libvirt_domain_create (value domv) + CAMLparam1 (domv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r; + + NONBLOCKING (r = virDomainCreate (dom)); +- CHECK_ERROR (r == -1, conn, "virDomainCreate"); ++ CHECK_ERROR (r == -1, "virDomainCreate"); + + CAMLreturn (Val_unit); + } +@@ -1016,12 +1000,11 @@ ocaml_libvirt_domain_attach_device (value domv, value strv) + CAMLparam2 (domv, strv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *str = String_val (strv); + int r; + + NONBLOCKING (r = virDomainAttachDevice (dom, str)); +- CHECK_ERROR (r == -1, conn, "virDomainAttachDevice"); ++ CHECK_ERROR (r == -1, "virDomainAttachDevice"); + + CAMLreturn (Val_unit); + } +@@ -1036,12 +1019,11 @@ ocaml_libvirt_domain_detach_device (value domv, value strv) + CAMLparam2 (domv, strv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *str = String_val (strv); + int r; + + NONBLOCKING (r = virDomainDetachDevice (dom, str)); +- CHECK_ERROR (r == -1, conn, "virDomainDetachDevice"); ++ CHECK_ERROR (r == -1, "virDomainDetachDevice"); + + CAMLreturn (Val_unit); + } +@@ -1056,11 +1038,10 @@ ocaml_libvirt_domain_get_autostart (value domv) + CAMLparam1 (domv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r, b; + + NONBLOCKING (r = virDomainGetAutostart (dom, &b)); +- CHECK_ERROR (r == -1, conn, "virDomainGetAutostart"); ++ CHECK_ERROR (r == -1, "virDomainGetAutostart"); + + CAMLreturn (b ? Val_true : Val_false); + } +@@ -1075,13 +1056,12 @@ ocaml_libvirt_domain_set_autostart (value domv, value bv) + CAMLparam2 (domv, bv); + + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r, b; + + b = bv == Val_true ? 1 : 0; + + NONBLOCKING (r = virDomainSetAutostart (dom, b)); +- CHECK_ERROR (r == -1, conn, "virDomainSetAutostart"); ++ CHECK_ERROR (r == -1, "virDomainSetAutostart"); + + CAMLreturn (Val_unit); + } +@@ -1096,11 +1076,10 @@ ocaml_libvirt_network_free (value netv) + CAMLparam1 (netv); + + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + int r; + + NONBLOCKING (r = virNetworkFree (net)); +- CHECK_ERROR (r == -1, conn, "virNetworkFree"); ++ CHECK_ERROR (r == -1, "virNetworkFree"); + + /* So that we don't double-free in the finalizer: */ + Network_val (netv) = NULL; +@@ -1118,11 +1097,10 @@ ocaml_libvirt_network_destroy (value netv) + CAMLparam1 (netv); + + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + int r; + + NONBLOCKING (r = virNetworkDestroy (net)); +- CHECK_ERROR (r == -1, conn, "virNetworkDestroy"); ++ CHECK_ERROR (r == -1, "virNetworkDestroy"); + + /* So that we don't double-free in the finalizer: */ + Network_val (netv) = NULL; +@@ -1145,7 +1123,7 @@ ocaml_libvirt_network_lookup_by_name (value connv, value strv) + virNetworkPtr r; + + NONBLOCKING (r = virNetworkLookupByName (conn, str)); +- CHECK_ERROR (!r, conn, "virNetworkLookupByName"); ++ CHECK_ERROR (!r, "virNetworkLookupByName"); + + rv = Val_network (r, connv); + +@@ -1167,7 +1145,7 @@ ocaml_libvirt_network_lookup_by_uuid (value connv, value uuidv) + virNetworkPtr r; + + NONBLOCKING (r = virNetworkLookupByUUID (conn, uuid)); +- CHECK_ERROR (!r, conn, "virNetworkLookupByUUID"); ++ CHECK_ERROR (!r, "virNetworkLookupByUUID"); + + rv = Val_network (r, connv); + +@@ -1189,7 +1167,7 @@ ocaml_libvirt_network_lookup_by_uuid_string (value connv, value strv) + virNetworkPtr r; + + NONBLOCKING (r = virNetworkLookupByUUIDString (conn, str)); +- CHECK_ERROR (!r, conn, "virNetworkLookupByUUIDString"); ++ CHECK_ERROR (!r, "virNetworkLookupByUUIDString"); + + rv = Val_network (r, connv); + +@@ -1207,11 +1185,10 @@ ocaml_libvirt_network_get_name (value netv) + + CAMLlocal1 (rv); + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + const char *r; + + NONBLOCKING (r = virNetworkGetName (net)); +- CHECK_ERROR (!r, conn, "virNetworkGetName"); ++ CHECK_ERROR (!r, "virNetworkGetName"); + + rv = caml_copy_string (r); + CAMLreturn (rv); +@@ -1228,11 +1205,10 @@ ocaml_libvirt_network_get_xml_desc (value netv) + + CAMLlocal1 (rv); + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + char *r; + + NONBLOCKING (r = virNetworkGetXMLDesc (net, 0)); +- CHECK_ERROR (!r, conn, "virNetworkGetXMLDesc"); ++ CHECK_ERROR (!r, "virNetworkGetXMLDesc"); + + rv = caml_copy_string (r); + free (r); +@@ -1250,11 +1226,10 @@ ocaml_libvirt_network_get_bridge_name (value netv) + + CAMLlocal1 (rv); + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + char *r; + + NONBLOCKING (r = virNetworkGetBridgeName (net)); +- CHECK_ERROR (!r, conn, "virNetworkGetBridgeName"); ++ CHECK_ERROR (!r, "virNetworkGetBridgeName"); + + rv = caml_copy_string (r); + free (r); +@@ -1272,12 +1247,11 @@ ocaml_libvirt_network_get_uuid (value netv) + + CAMLlocal1 (rv); + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + unsigned char uuid[VIR_UUID_BUFLEN]; + int r; + + NONBLOCKING (r = virNetworkGetUUID (net, uuid)); +- CHECK_ERROR (r == -1, conn, "virNetworkGetUUID"); ++ CHECK_ERROR (r == -1, "virNetworkGetUUID"); + + /* UUIDs are byte arrays with a fixed length. */ + rv = caml_alloc_string (VIR_UUID_BUFLEN); +@@ -1296,12 +1270,11 @@ ocaml_libvirt_network_get_uuid_string (value netv) + + CAMLlocal1 (rv); + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + char uuid[VIR_UUID_STRING_BUFLEN]; + int r; + + NONBLOCKING (r = virNetworkGetUUIDString (net, uuid)); +- CHECK_ERROR (r == -1, conn, "virNetworkGetUUIDString"); ++ CHECK_ERROR (r == -1, "virNetworkGetUUIDString"); + + rv = caml_copy_string (uuid); + CAMLreturn (rv); +@@ -1317,11 +1290,10 @@ ocaml_libvirt_network_undefine (value netv) + CAMLparam1 (netv); + + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + int r; + + NONBLOCKING (r = virNetworkUndefine (net)); +- CHECK_ERROR (r == -1, conn, "virNetworkUndefine"); ++ CHECK_ERROR (r == -1, "virNetworkUndefine"); + + CAMLreturn (Val_unit); + } +@@ -1341,7 +1313,7 @@ ocaml_libvirt_network_create_xml (value connv, value strv) + virNetworkPtr r; + + NONBLOCKING (r = virNetworkCreateXML (conn, str)); +- CHECK_ERROR (!r, conn, "virNetworkCreateXML"); ++ CHECK_ERROR (!r, "virNetworkCreateXML"); + + rv = Val_network (r, connv); + +@@ -1363,7 +1335,7 @@ ocaml_libvirt_network_define_xml (value connv, value strv) + virNetworkPtr r; + + NONBLOCKING (r = virNetworkDefineXML (conn, str)); +- CHECK_ERROR (!r, conn, "virNetworkDefineXML"); ++ CHECK_ERROR (!r, "virNetworkDefineXML"); + + rv = Val_network (r, connv); + +@@ -1380,11 +1352,10 @@ ocaml_libvirt_network_create (value netv) + CAMLparam1 (netv); + + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + int r; + + NONBLOCKING (r = virNetworkCreate (net)); +- CHECK_ERROR (r == -1, conn, "virNetworkCreate"); ++ CHECK_ERROR (r == -1, "virNetworkCreate"); + + CAMLreturn (Val_unit); + } +@@ -1399,11 +1370,10 @@ ocaml_libvirt_network_get_autostart (value netv) + CAMLparam1 (netv); + + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + int r, b; + + NONBLOCKING (r = virNetworkGetAutostart (net, &b)); +- CHECK_ERROR (r == -1, conn, "virNetworkGetAutostart"); ++ CHECK_ERROR (r == -1, "virNetworkGetAutostart"); + + CAMLreturn (b ? Val_true : Val_false); + } +@@ -1418,13 +1388,12 @@ ocaml_libvirt_network_set_autostart (value netv, value bv) + CAMLparam2 (netv, bv); + + virNetworkPtr net = Network_val (netv); +- virConnectPtr conn = Connect_netv (netv); + int r, b; + + b = bv == Val_true ? 1 : 0; + + NONBLOCKING (r = virNetworkSetAutostart (net, b)); +- CHECK_ERROR (r == -1, conn, "virNetworkSetAutostart"); ++ CHECK_ERROR (r == -1, "virNetworkSetAutostart"); + + CAMLreturn (Val_unit); + } +@@ -1439,11 +1408,10 @@ ocaml_libvirt_storage_pool_free (value poolv) + CAMLparam1 (poolv); + + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + int r; + + NONBLOCKING (r = virStoragePoolFree (pool)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolFree"); ++ CHECK_ERROR (r == -1, "virStoragePoolFree"); + + /* So that we don't double-free in the finalizer: */ + Pool_val (poolv) = NULL; +@@ -1461,11 +1429,10 @@ ocaml_libvirt_storage_pool_destroy (value poolv) + CAMLparam1 (poolv); + + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + int r; + + NONBLOCKING (r = virStoragePoolDestroy (pool)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolDestroy"); ++ CHECK_ERROR (r == -1, "virStoragePoolDestroy"); + + /* So that we don't double-free in the finalizer: */ + Pool_val (poolv) = NULL; +@@ -1488,7 +1455,7 @@ ocaml_libvirt_storage_pool_lookup_by_name (value connv, value strv) + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolLookupByName (conn, str)); +- CHECK_ERROR (!r, conn, "virStoragePoolLookupByName"); ++ CHECK_ERROR (!r, "virStoragePoolLookupByName"); + + rv = Val_pool (r, connv); + +@@ -1510,7 +1477,7 @@ ocaml_libvirt_storage_pool_lookup_by_uuid (value connv, value uuidv) + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolLookupByUUID (conn, uuid)); +- CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUID"); ++ CHECK_ERROR (!r, "virStoragePoolLookupByUUID"); + + rv = Val_pool (r, connv); + +@@ -1532,7 +1499,7 @@ ocaml_libvirt_storage_pool_lookup_by_uuid_string (value connv, value strv) + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolLookupByUUIDString (conn, str)); +- CHECK_ERROR (!r, conn, "virStoragePoolLookupByUUIDString"); ++ CHECK_ERROR (!r, "virStoragePoolLookupByUUIDString"); + + rv = Val_pool (r, connv); + +@@ -1550,11 +1517,10 @@ ocaml_libvirt_storage_pool_get_name (value poolv) + + CAMLlocal1 (rv); + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + const char *r; + + NONBLOCKING (r = virStoragePoolGetName (pool)); +- CHECK_ERROR (!r, conn, "virStoragePoolGetName"); ++ CHECK_ERROR (!r, "virStoragePoolGetName"); + + rv = caml_copy_string (r); + CAMLreturn (rv); +@@ -1571,11 +1537,10 @@ ocaml_libvirt_storage_pool_get_xml_desc (value poolv) + + CAMLlocal1 (rv); + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + char *r; + + NONBLOCKING (r = virStoragePoolGetXMLDesc (pool, 0)); +- CHECK_ERROR (!r, conn, "virStoragePoolGetXMLDesc"); ++ CHECK_ERROR (!r, "virStoragePoolGetXMLDesc"); + + rv = caml_copy_string (r); + free (r); +@@ -1593,12 +1558,11 @@ ocaml_libvirt_storage_pool_get_uuid (value poolv) + + CAMLlocal1 (rv); + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + unsigned char uuid[VIR_UUID_BUFLEN]; + int r; + + NONBLOCKING (r = virStoragePoolGetUUID (pool, uuid)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolGetUUID"); ++ CHECK_ERROR (r == -1, "virStoragePoolGetUUID"); + + /* UUIDs are byte arrays with a fixed length. */ + rv = caml_alloc_string (VIR_UUID_BUFLEN); +@@ -1617,12 +1581,11 @@ ocaml_libvirt_storage_pool_get_uuid_string (value poolv) + + CAMLlocal1 (rv); + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + char uuid[VIR_UUID_STRING_BUFLEN]; + int r; + + NONBLOCKING (r = virStoragePoolGetUUIDString (pool, uuid)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolGetUUIDString"); ++ CHECK_ERROR (r == -1, "virStoragePoolGetUUIDString"); + + rv = caml_copy_string (uuid); + CAMLreturn (rv); +@@ -1643,7 +1606,7 @@ ocaml_libvirt_storage_pool_create_xml (value connv, value strv) + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolCreateXML (conn, str, 0)); +- CHECK_ERROR (!r, conn, "virStoragePoolCreateXML"); ++ CHECK_ERROR (!r, "virStoragePoolCreateXML"); + + rv = Val_pool (r, connv); + +@@ -1665,7 +1628,7 @@ ocaml_libvirt_storage_pool_define_xml (value connv, value strv) + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolDefineXML (conn, str, 0)); +- CHECK_ERROR (!r, conn, "virStoragePoolDefineXML"); ++ CHECK_ERROR (!r, "virStoragePoolDefineXML"); + + rv = Val_pool (r, connv); + +@@ -1682,12 +1645,11 @@ ocaml_libvirt_storage_pool_build (value poolv, value iv) + CAMLparam2 (poolv, iv); + + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + unsigned int i = Int_val (iv); + int r; + + NONBLOCKING (r = virStoragePoolBuild (pool, i)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolBuild"); ++ CHECK_ERROR (r == -1, "virStoragePoolBuild"); + + CAMLreturn (Val_unit); + } +@@ -1702,11 +1664,10 @@ ocaml_libvirt_storage_pool_undefine (value poolv) + CAMLparam1 (poolv); + + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + int r; + + NONBLOCKING (r = virStoragePoolUndefine (pool)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolUndefine"); ++ CHECK_ERROR (r == -1, "virStoragePoolUndefine"); + + CAMLreturn (Val_unit); + } +@@ -1721,11 +1682,10 @@ ocaml_libvirt_storage_pool_create (value poolv) + CAMLparam1 (poolv); + + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + int r; + + NONBLOCKING (r = virStoragePoolCreate (pool, 0)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolCreate"); ++ CHECK_ERROR (r == -1, "virStoragePoolCreate"); + + CAMLreturn (Val_unit); + } +@@ -1740,12 +1700,11 @@ ocaml_libvirt_storage_pool_delete (value poolv, value iv) + CAMLparam2 (poolv, iv); + + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + unsigned int i = Int_val (iv); + int r; + + NONBLOCKING (r = virStoragePoolDelete (pool, i)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolDelete"); ++ CHECK_ERROR (r == -1, "virStoragePoolDelete"); + + CAMLreturn (Val_unit); + } +@@ -1760,11 +1719,10 @@ ocaml_libvirt_storage_pool_refresh (value poolv) + CAMLparam1 (poolv); + + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + int r; + + NONBLOCKING (r = virStoragePoolRefresh (pool, 0)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolRefresh"); ++ CHECK_ERROR (r == -1, "virStoragePoolRefresh"); + + CAMLreturn (Val_unit); + } +@@ -1779,11 +1737,10 @@ ocaml_libvirt_storage_pool_get_autostart (value poolv) + CAMLparam1 (poolv); + + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + int r, b; + + NONBLOCKING (r = virStoragePoolGetAutostart (pool, &b)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolGetAutostart"); ++ CHECK_ERROR (r == -1, "virStoragePoolGetAutostart"); + + CAMLreturn (b ? Val_true : Val_false); + } +@@ -1798,13 +1755,12 @@ ocaml_libvirt_storage_pool_set_autostart (value poolv, value bv) + CAMLparam2 (poolv, bv); + + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + int r, b; + + b = bv == Val_true ? 1 : 0; + + NONBLOCKING (r = virStoragePoolSetAutostart (pool, b)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolSetAutostart"); ++ CHECK_ERROR (r == -1, "virStoragePoolSetAutostart"); + + CAMLreturn (Val_unit); + } +@@ -1819,11 +1775,10 @@ ocaml_libvirt_storage_pool_num_of_volumes (value poolv) + CAMLparam1 (poolv); + + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + int r; + + NONBLOCKING (r = virStoragePoolNumOfVolumes (pool)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolNumOfVolumes"); ++ CHECK_ERROR (r == -1, "virStoragePoolNumOfVolumes"); + + CAMLreturn (Val_int (r)); + } +@@ -1839,7 +1794,6 @@ ocaml_libvirt_storage_pool_list_volumes (value poolv, value iv) + + CAMLlocal2 (rv, strv); + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + int i = Int_val (iv); + char *names[i]; + int r; +@@ -1855,7 +1809,7 @@ ocaml_libvirt_storage_pool_list_volumes (value poolv, value iv) + } + + NONBLOCKING (r = virStoragePoolListVolumes (pool, names, i)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolListVolumes"); ++ CHECK_ERROR (r == -1, "virStoragePoolListVolumes"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +@@ -1877,11 +1831,10 @@ ocaml_libvirt_storage_vol_free (value volv) + CAMLparam1 (volv); + + virStorageVolPtr vol = Volume_val (volv); +- virConnectPtr conn = Connect_volv (volv); + int r; + + NONBLOCKING (r = virStorageVolFree (vol)); +- CHECK_ERROR (r == -1, conn, "virStorageVolFree"); ++ CHECK_ERROR (r == -1, "virStorageVolFree"); + + /* So that we don't double-free in the finalizer: */ + Volume_val (volv) = NULL; +@@ -1899,12 +1852,11 @@ ocaml_libvirt_storage_vol_delete (value volv, value iv) + CAMLparam2 (volv, iv); + + virStorageVolPtr vol = Volume_val (volv); +- virConnectPtr conn = Connect_volv (volv); + unsigned int i = Int_val (iv); + int r; + + NONBLOCKING (r = virStorageVolDelete (vol, i)); +- CHECK_ERROR (r == -1, conn, "virStorageVolDelete"); ++ CHECK_ERROR (r == -1, "virStorageVolDelete"); + + CAMLreturn (Val_unit); + } +@@ -1920,12 +1872,11 @@ ocaml_libvirt_storage_vol_lookup_by_name (value poolv, value strv) + + CAMLlocal2 (rv, connv); + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + char *str = String_val (strv); + virStorageVolPtr r; + + NONBLOCKING (r = virStorageVolLookupByName (pool, str)); +- CHECK_ERROR (!r, conn, "virStorageVolLookupByName"); ++ CHECK_ERROR (!r, "virStorageVolLookupByName"); + + connv = Field (poolv, 1); + rv = Val_volume (r, connv); +@@ -1948,7 +1899,7 @@ ocaml_libvirt_storage_vol_lookup_by_key (value connv, value strv) + virStorageVolPtr r; + + NONBLOCKING (r = virStorageVolLookupByKey (conn, str)); +- CHECK_ERROR (!r, conn, "virStorageVolLookupByKey"); ++ CHECK_ERROR (!r, "virStorageVolLookupByKey"); + + rv = Val_volume (r, connv); + +@@ -1970,7 +1921,7 @@ ocaml_libvirt_storage_vol_lookup_by_path (value connv, value strv) + virStorageVolPtr r; + + NONBLOCKING (r = virStorageVolLookupByPath (conn, str)); +- CHECK_ERROR (!r, conn, "virStorageVolLookupByPath"); ++ CHECK_ERROR (!r, "virStorageVolLookupByPath"); + + rv = Val_volume (r, connv); + +@@ -1988,12 +1939,11 @@ ocaml_libvirt_storage_vol_create_xml (value poolv, value strv) + + CAMLlocal2 (rv, connv); + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + char *str = String_val (strv); + virStorageVolPtr r; + + NONBLOCKING (r = virStorageVolCreateXML (pool, str, 0)); +- CHECK_ERROR (!r, conn, "virStorageVolCreateXML"); ++ CHECK_ERROR (!r, "virStorageVolCreateXML"); + + connv = Field (poolv, 1); + rv = Val_volume (r, connv); +@@ -2012,11 +1962,10 @@ ocaml_libvirt_storage_vol_get_xml_desc (value volv) + + CAMLlocal1 (rv); + virStorageVolPtr vol = Volume_val (volv); +- virConnectPtr conn = Connect_volv (volv); + char *r; + + NONBLOCKING (r = virStorageVolGetXMLDesc (vol, 0)); +- CHECK_ERROR (!r, conn, "virStorageVolGetXMLDesc"); ++ CHECK_ERROR (!r, "virStorageVolGetXMLDesc"); + + rv = caml_copy_string (r); + free (r); +@@ -2034,11 +1983,10 @@ ocaml_libvirt_storage_vol_get_path (value volv) + + CAMLlocal1 (rv); + virStorageVolPtr vol = Volume_val (volv); +- virConnectPtr conn = Connect_volv (volv); + char *r; + + NONBLOCKING (r = virStorageVolGetPath (vol)); +- CHECK_ERROR (!r, conn, "virStorageVolGetPath"); ++ CHECK_ERROR (!r, "virStorageVolGetPath"); + + rv = caml_copy_string (r); + free (r); +@@ -2056,11 +2004,10 @@ ocaml_libvirt_storage_vol_get_key (value volv) + + CAMLlocal1 (rv); + virStorageVolPtr vol = Volume_val (volv); +- virConnectPtr conn = Connect_volv (volv); + const char *r; + + NONBLOCKING (r = virStorageVolGetKey (vol)); +- CHECK_ERROR (!r, conn, "virStorageVolGetKey"); ++ CHECK_ERROR (!r, "virStorageVolGetKey"); + + rv = caml_copy_string (r); + CAMLreturn (rv); +@@ -2077,11 +2024,10 @@ ocaml_libvirt_storage_vol_get_name (value volv) + + CAMLlocal1 (rv); + virStorageVolPtr vol = Volume_val (volv); +- virConnectPtr conn = Connect_volv (volv); + const char *r; + + NONBLOCKING (r = virStorageVolGetName (vol)); +- CHECK_ERROR (!r, conn, "virStorageVolGetName"); ++ CHECK_ERROR (!r, "virStorageVolGetName"); + + rv = caml_copy_string (r); + CAMLreturn (rv); +@@ -2098,11 +2044,10 @@ ocaml_libvirt_storage_pool_lookup_by_volume (value volv) + + CAMLlocal2 (rv, connv); + virStorageVolPtr vol = Volume_val (volv); +- virConnectPtr conn = Connect_volv (volv); + virStoragePoolPtr r; + + NONBLOCKING (r = virStoragePoolLookupByVolume (vol)); +- CHECK_ERROR (!r, conn, "virStoragePoolLookupByVolume"); ++ CHECK_ERROR (!r, "virStoragePoolLookupByVolume"); + + connv = Field (volv, 1); + rv = Val_pool (r, connv); +diff --git a/libvirt/libvirt_c_epilogue.c b/libvirt/libvirt_c_epilogue.c +index 4649724..4972e50 100644 +--- a/libvirt/libvirt_c_epilogue.c ++++ b/libvirt/libvirt_c_epilogue.c +@@ -57,14 +57,14 @@ option_default (value option, value deflt) + #endif + + static void +-_raise_virterror (virConnectPtr conn, const char *fn) ++_raise_virterror (const char *fn) + { + CAMLparam0 (); + CAMLlocal1 (rv); + virErrorPtr errp; + struct _virError err; + +- errp = conn ? virConnGetLastError (conn) : virGetLastError (); ++ errp = virGetLastError (); + + if (!errp) { + /* Fake a _virError structure. */ +diff --git a/libvirt/libvirt_c_oneoffs.c b/libvirt/libvirt_c_oneoffs.c +index 06b3852..32e5a4b 100644 +--- a/libvirt/libvirt_c_oneoffs.c ++++ b/libvirt/libvirt_c_oneoffs.c +@@ -32,7 +32,7 @@ ocaml_libvirt_get_version (value driverv, value unit) + + typeVer_ptr = driver ? &typeVer : NULL; + NONBLOCKING (r = virGetVersion (&libVer, driver, typeVer_ptr)); +- CHECK_ERROR (r == -1, NULL, "virGetVersion"); ++ CHECK_ERROR (r == -1, "virGetVersion"); + + rv = caml_alloc_tuple (2); + Store_field (rv, 0, Val_int (libVer)); +@@ -53,7 +53,7 @@ ocaml_libvirt_connect_open (value namev, value unit) + virConnectPtr conn; + + NONBLOCKING (conn = virConnectOpen (name)); +- CHECK_ERROR (!conn, NULL, "virConnectOpen"); ++ CHECK_ERROR (!conn, "virConnectOpen"); + + rv = Val_connect (conn); + +@@ -69,7 +69,7 @@ ocaml_libvirt_connect_open_readonly (value namev, value unit) + virConnectPtr conn; + + NONBLOCKING (conn = virConnectOpenReadOnly (name)); +- CHECK_ERROR (!conn, NULL, "virConnectOpen"); ++ CHECK_ERROR (!conn, "virConnectOpen"); + + rv = Val_connect (conn); + +@@ -85,7 +85,7 @@ ocaml_libvirt_connect_get_version (value connv) + int r; + + NONBLOCKING (r = virConnectGetVersion (conn, &hvVer)); +- CHECK_ERROR (r == -1, conn, "virConnectGetVersion"); ++ CHECK_ERROR (r == -1, "virConnectGetVersion"); + + CAMLreturn (Val_int (hvVer)); + } +@@ -99,7 +99,7 @@ ocaml_libvirt_connect_get_max_vcpus (value connv, value typev) + int r; + + NONBLOCKING (r = virConnectGetMaxVcpus (conn, type)); +- CHECK_ERROR (r == -1, conn, "virConnectGetMaxVcpus"); ++ CHECK_ERROR (r == -1, "virConnectGetMaxVcpus"); + + CAMLreturn (Val_int (r)); + } +@@ -114,7 +114,7 @@ ocaml_libvirt_connect_get_node_info (value connv) + int r; + + NONBLOCKING (r = virNodeGetInfo (conn, &info)); +- CHECK_ERROR (r == -1, conn, "virNodeGetInfo"); ++ CHECK_ERROR (r == -1, "virNodeGetInfo"); + + rv = caml_alloc (8, 0); + v = caml_copy_string (info.model); Store_field (rv, 0, v); +@@ -138,7 +138,7 @@ ocaml_libvirt_connect_node_get_free_memory (value connv) + unsigned long long r; + + NONBLOCKING (r = virNodeGetFreeMemory (conn)); +- CHECK_ERROR (r == 0, conn, "virNodeGetFreeMemory"); ++ CHECK_ERROR (r == 0, "virNodeGetFreeMemory"); + + rv = caml_copy_int64 ((int64_t) r); + CAMLreturn (rv); +@@ -157,7 +157,7 @@ ocaml_libvirt_connect_node_get_cells_free_memory (value connv, + unsigned long long freemems[max]; + + NONBLOCKING (r = virNodeGetCellsFreeMemory (conn, freemems, start, max)); +- CHECK_ERROR (r == -1, conn, "virNodeGetCellsFreeMemory"); ++ CHECK_ERROR (r == -1, "virNodeGetCellsFreeMemory"); + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +@@ -179,7 +179,7 @@ ocaml_libvirt_connect_set_keep_alive(value connv, + int r; + + NONBLOCKING(r = virConnectSetKeepAlive(conn, interval, count)); +- CHECK_ERROR (r == -1, conn, "virConnectSetKeepAlive"); ++ CHECK_ERROR (r == -1, "virConnectSetKeepAlive"); + + CAMLreturn(Val_unit); + } +@@ -190,7 +190,6 @@ ocaml_libvirt_domain_get_id (value domv) + { + CAMLparam1 (domv); + virDomainPtr dom = Domain_val (domv); +- /*virConnectPtr conn = Connect_domv (domv);*/ + unsigned int r; + + NONBLOCKING (r = virDomainGetID (dom)); +@@ -208,11 +207,10 @@ ocaml_libvirt_domain_get_max_memory (value domv) + CAMLparam1 (domv); + CAMLlocal1 (rv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + unsigned long r; + + NONBLOCKING (r = virDomainGetMaxMemory (dom)); +- CHECK_ERROR (r == 0 /* [sic] */, conn, "virDomainGetMaxMemory"); ++ CHECK_ERROR (r == 0 /* [sic] */, "virDomainGetMaxMemory"); + + rv = caml_copy_int64 (r); + CAMLreturn (rv); +@@ -223,12 +221,11 @@ ocaml_libvirt_domain_set_max_memory (value domv, value memv) + { + CAMLparam2 (domv, memv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + unsigned long mem = Int64_val (memv); + int r; + + NONBLOCKING (r = virDomainSetMaxMemory (dom, mem)); +- CHECK_ERROR (r == -1, conn, "virDomainSetMaxMemory"); ++ CHECK_ERROR (r == -1, "virDomainSetMaxMemory"); + + CAMLreturn (Val_unit); + } +@@ -238,12 +235,11 @@ ocaml_libvirt_domain_set_memory (value domv, value memv) + { + CAMLparam2 (domv, memv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + unsigned long mem = Int64_val (memv); + int r; + + NONBLOCKING (r = virDomainSetMemory (dom, mem)); +- CHECK_ERROR (r == -1, conn, "virDomainSetMemory"); ++ CHECK_ERROR (r == -1, "virDomainSetMemory"); + + CAMLreturn (Val_unit); + } +@@ -254,12 +250,11 @@ ocaml_libvirt_domain_get_info (value domv) + CAMLparam1 (domv); + CAMLlocal2 (rv, v); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + virDomainInfo info; + int r; + + NONBLOCKING (r = virDomainGetInfo (dom, &info)); +- CHECK_ERROR (r == -1, conn, "virDomainGetInfo"); ++ CHECK_ERROR (r == -1, "virDomainGetInfo"); + + rv = caml_alloc (5, 0); + Store_field (rv, 0, Val_int (info.state)); // These flags are compatible. +@@ -277,12 +272,11 @@ ocaml_libvirt_domain_get_scheduler_type (value domv) + CAMLparam1 (domv); + CAMLlocal2 (rv, strv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *r; + int nparams; + + NONBLOCKING (r = virDomainGetSchedulerType (dom, &nparams)); +- CHECK_ERROR (!r, conn, "virDomainGetSchedulerType"); ++ CHECK_ERROR (!r, "virDomainGetSchedulerType"); + + rv = caml_alloc_tuple (2); + strv = caml_copy_string (r); Store_field (rv, 0, strv); +@@ -297,13 +291,12 @@ ocaml_libvirt_domain_get_scheduler_parameters (value domv, value nparamsv) + CAMLparam2 (domv, nparamsv); + CAMLlocal4 (rv, v, v2, v3); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int nparams = Int_val (nparamsv); + virSchedParameter params[nparams]; + int r, i; + + NONBLOCKING (r = virDomainGetSchedulerParameters (dom, params, &nparams)); +- CHECK_ERROR (r == -1, conn, "virDomainGetSchedulerParameters"); ++ CHECK_ERROR (r == -1, "virDomainGetSchedulerParameters"); + + rv = caml_alloc (nparams, 0); + for (i = 0; i < nparams; ++i) { +@@ -348,7 +341,6 @@ ocaml_libvirt_domain_set_scheduler_parameters (value domv, value paramsv) + CAMLparam2 (domv, paramsv); + CAMLlocal1 (v); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int nparams = Wosize_val (paramsv); + virSchedParameter params[nparams]; + int r, i; +@@ -391,7 +383,7 @@ ocaml_libvirt_domain_set_scheduler_parameters (value domv, value paramsv) + } + + NONBLOCKING (r = virDomainSetSchedulerParameters (dom, params, nparams)); +- CHECK_ERROR (r == -1, conn, "virDomainSetSchedulerParameters"); ++ CHECK_ERROR (r == -1, "virDomainSetSchedulerParameters"); + + CAMLreturn (Val_unit); + } +@@ -401,11 +393,10 @@ ocaml_libvirt_domain_set_vcpus (value domv, value nvcpusv) + { + CAMLparam2 (domv, nvcpusv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int r, nvcpus = Int_val (nvcpusv); + + NONBLOCKING (r = virDomainSetVcpus (dom, nvcpus)); +- CHECK_ERROR (r == -1, conn, "virDomainSetVcpus"); ++ CHECK_ERROR (r == -1, "virDomainSetVcpus"); + + CAMLreturn (Val_unit); + } +@@ -415,14 +406,13 @@ ocaml_libvirt_domain_pin_vcpu (value domv, value vcpuv, value cpumapv) + { + CAMLparam3 (domv, vcpuv, cpumapv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int maplen = caml_string_length (cpumapv); + unsigned char *cpumap = (unsigned char *) String_val (cpumapv); + int vcpu = Int_val (vcpuv); + int r; + + NONBLOCKING (r = virDomainPinVcpu (dom, vcpu, cpumap, maplen)); +- CHECK_ERROR (r == -1, conn, "virDomainPinVcpu"); ++ CHECK_ERROR (r == -1, "virDomainPinVcpu"); + + CAMLreturn (Val_unit); + } +@@ -433,7 +423,6 @@ ocaml_libvirt_domain_get_vcpus (value domv, value maxinfov, value maplenv) + CAMLparam3 (domv, maxinfov, maplenv); + CAMLlocal5 (rv, infov, strv, v, v2); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int maxinfo = Int_val (maxinfov); + int maplen = Int_val (maplenv); + virVcpuInfo info[maxinfo]; +@@ -444,7 +433,7 @@ ocaml_libvirt_domain_get_vcpus (value domv, value maxinfov, value maplenv) + memset (cpumaps, 0, maxinfo * maplen); + + NONBLOCKING (r = virDomainGetVcpus (dom, info, maxinfo, cpumaps, maplen)); +- CHECK_ERROR (r == -1, conn, "virDomainPinVcpu"); ++ CHECK_ERROR (r == -1, "virDomainPinVcpu"); + + /* Copy the virVcpuInfo structures. */ + infov = caml_alloc (maxinfo, 0); +@@ -476,18 +465,17 @@ ocaml_libvirt_domain_get_cpu_stats (value domv) + CAMLlocal5 (cpustats, param_head, param_node, typed_param, typed_param_value); + CAMLlocal1 (v); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + virTypedParameterPtr params; + int r, cpu, ncpus, nparams, i, j, pos; + int nr_pcpus; + + /* get number of pcpus */ + NONBLOCKING (nr_pcpus = virDomainGetCPUStats(dom, NULL, 0, 0, 0, 0)); +- CHECK_ERROR (nr_pcpus < 0, conn, "virDomainGetCPUStats"); ++ CHECK_ERROR (nr_pcpus < 0, "virDomainGetCPUStats"); + + /* get percpu information */ + NONBLOCKING (nparams = virDomainGetCPUStats(dom, NULL, 0, 0, 1, 0)); +- CHECK_ERROR (nparams < 0, conn, "virDomainGetCPUStats"); ++ CHECK_ERROR (nparams < 0, "virDomainGetCPUStats"); + + if ((params = malloc(sizeof(*params) * nparams * 128)) == NULL) + caml_failwith ("virDomainGetCPUStats: malloc"); +@@ -498,7 +486,7 @@ ocaml_libvirt_domain_get_cpu_stats (value domv) + ncpus = nr_pcpus - cpu > 128 ? 128 : nr_pcpus - cpu; + + NONBLOCKING (r = virDomainGetCPUStats(dom, params, nparams, cpu, ncpus, 0)); +- CHECK_ERROR (r < 0, conn, "virDomainGetCPUStats"); ++ CHECK_ERROR (r < 0, "virDomainGetCPUStats"); + + for (i = 0; i < ncpus; i++) { + /* list of typed_param: single linked list of param_nodes */ +@@ -579,7 +567,6 @@ ocaml_libvirt_domain_migrate_native (value domv, value dconnv, value flagsv, val + CAMLxparam2 (optbandwidthv, unitv); + CAMLlocal2 (flagv, rv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + virConnectPtr dconn = Connect_val (dconnv); + int flags = 0; + const char *dname = Optstring_val (optdnamev); +@@ -601,7 +588,7 @@ ocaml_libvirt_domain_migrate_native (value domv, value dconnv, value flagsv, val + bandwidth = Int_val (Field (optbandwidthv, 0)); + + NONBLOCKING (r = virDomainMigrate (dom, dconn, flags, dname, uri, bandwidth)); +- CHECK_ERROR (!r, conn, "virDomainMigrate"); ++ CHECK_ERROR (!r, "virDomainMigrate"); + + rv = Val_domain (r, dconnv); + +@@ -622,13 +609,12 @@ ocaml_libvirt_domain_block_stats (value domv, value pathv) + CAMLparam2 (domv, pathv); + CAMLlocal2 (rv,v); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *path = String_val (pathv); + struct _virDomainBlockStats stats; + int r; + + NONBLOCKING (r = virDomainBlockStats (dom, path, &stats, sizeof stats)); +- CHECK_ERROR (r == -1, conn, "virDomainBlockStats"); ++ CHECK_ERROR (r == -1, "virDomainBlockStats"); + + rv = caml_alloc (5, 0); + v = caml_copy_int64 (stats.rd_req); Store_field (rv, 0, v); +@@ -646,13 +632,12 @@ ocaml_libvirt_domain_interface_stats (value domv, value pathv) + CAMLparam2 (domv, pathv); + CAMLlocal2 (rv,v); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + char *path = String_val (pathv); + struct _virDomainInterfaceStats stats; + int r; + + NONBLOCKING (r = virDomainInterfaceStats (dom, path, &stats, sizeof stats)); +- CHECK_ERROR (r == -1, conn, "virDomainInterfaceStats"); ++ CHECK_ERROR (r == -1, "virDomainInterfaceStats"); + + rv = caml_alloc (8, 0); + v = caml_copy_int64 (stats.rx_bytes); Store_field (rv, 0, v); +@@ -673,7 +658,6 @@ ocaml_libvirt_domain_block_peek_native (value domv, value pathv, value offsetv, + CAMLparam5 (domv, pathv, offsetv, sizev, bufferv); + CAMLxparam1 (boffv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + const char *path = String_val (pathv); + unsigned long long offset = Int64_val (offsetv); + size_t size = Int_val (sizev); +@@ -687,7 +671,7 @@ ocaml_libvirt_domain_block_peek_native (value domv, value pathv, value offsetv, + + /* NB. not NONBLOCKING because buffer might move (XXX) */ + r = virDomainBlockPeek (dom, path, offset, size, buffer+boff, 0); +- CHECK_ERROR (r == -1, conn, "virDomainBlockPeek"); ++ CHECK_ERROR (r == -1, "virDomainBlockPeek"); + + CAMLreturn (Val_unit); + } +@@ -706,7 +690,6 @@ ocaml_libvirt_domain_memory_peek_native (value domv, value flagsv, value offsetv + CAMLxparam1 (boffv); + CAMLlocal1 (flagv); + virDomainPtr dom = Domain_val (domv); +- virConnectPtr conn = Connect_domv (domv); + int flags = 0; + unsigned long long offset = Int64_val (offsetv); + size_t size = Int_val (sizev); +@@ -728,7 +711,7 @@ ocaml_libvirt_domain_memory_peek_native (value domv, value flagsv, value offsetv + + /* NB. not NONBLOCKING because buffer might move (XXX) */ + r = virDomainMemoryPeek (dom, offset, size, buffer+boff, flags); +- CHECK_ERROR (r == -1, conn, "virDomainMemoryPeek"); ++ CHECK_ERROR (r == -1, "virDomainMemoryPeek"); + + CAMLreturn (Val_unit); + } +@@ -1042,7 +1025,6 @@ CAMLprim value + ocaml_libvirt_event_add_timeout (value connv, value ms, value callback_id) + { + CAMLparam3 (connv, ms, callback_id); +- virConnectPtr conn = Connect_val (connv); + void *opaque; + virFreeCallback freecb = free; + virEventTimeoutCallback cb = timeout_callback; +@@ -1055,7 +1037,7 @@ ocaml_libvirt_event_add_timeout (value connv, value ms, value callback_id) + caml_failwith ("virEventAddTimeout: malloc"); + *((long*)opaque) = Int64_val(callback_id); + NONBLOCKING(r = virEventAddTimeout(Int_val(ms), cb, opaque, freecb)); +- CHECK_ERROR(r == -1, conn, "virEventAddTimeout"); ++ CHECK_ERROR(r == -1, "virEventAddTimeout"); + + CAMLreturn(Val_int(r)); + } +@@ -1064,11 +1046,10 @@ CAMLprim value + ocaml_libvirt_event_remove_timeout (value connv, value timer_id) + { + CAMLparam2 (connv, timer_id); +- virConnectPtr conn = Connect_val (connv); + int r; + + NONBLOCKING(r = virEventRemoveTimeout(Int_val(timer_id))); +- CHECK_ERROR(r == -1, conn, "virEventRemoveTimeout"); ++ CHECK_ERROR(r == -1, "virEventRemoveTimeout"); + + CAMLreturn(Val_int(r)); + } +@@ -1146,7 +1127,7 @@ ocaml_libvirt_connect_domain_event_register_any(value connv, value domv, value c + caml_failwith ("virConnectDomainEventRegisterAny: malloc"); + *((long*)opaque) = Int64_val(callback_id); + NONBLOCKING(r = virConnectDomainEventRegisterAny(conn, dom, eventID, cb, opaque, freecb)); +- CHECK_ERROR(r == -1, conn, "virConnectDomainEventRegisterAny"); ++ CHECK_ERROR(r == -1, "virConnectDomainEventRegisterAny"); + + CAMLreturn(Val_int(r)); + } +@@ -1157,12 +1138,11 @@ ocaml_libvirt_storage_pool_get_info (value poolv) + CAMLparam1 (poolv); + CAMLlocal2 (rv, v); + virStoragePoolPtr pool = Pool_val (poolv); +- virConnectPtr conn = Connect_polv (poolv); + virStoragePoolInfo info; + int r; + + NONBLOCKING (r = virStoragePoolGetInfo (pool, &info)); +- CHECK_ERROR (r == -1, conn, "virStoragePoolGetInfo"); ++ CHECK_ERROR (r == -1, "virStoragePoolGetInfo"); + + rv = caml_alloc (4, 0); + Store_field (rv, 0, Val_int (info.state)); +@@ -1179,12 +1159,11 @@ ocaml_libvirt_storage_vol_get_info (value volv) + CAMLparam1 (volv); + CAMLlocal2 (rv, v); + virStorageVolPtr vol = Volume_val (volv); +- virConnectPtr conn = Connect_volv (volv); + virStorageVolInfo info; + int r; + + NONBLOCKING (r = virStorageVolGetInfo (vol, &info)); +- CHECK_ERROR (r == -1, conn, "virStorageVolGetInfo"); ++ CHECK_ERROR (r == -1, "virStorageVolGetInfo"); + + rv = caml_alloc (3, 0); + Store_field (rv, 0, Val_int (info.type)); +@@ -1239,6 +1218,12 @@ ocaml_libvirt_virterror_reset_last_conn_error (value connv) + + /*----------------------------------------------------------------------*/ + ++static void ++ignore_errors (void *user_data, virErrorPtr error) ++{ ++ /* do nothing */ ++} ++ + /* Initialise the library. */ + CAMLprim value + ocaml_libvirt_init (value unit) +@@ -1247,8 +1232,9 @@ ocaml_libvirt_init (value unit) + CAMLlocal1 (rv); + int r; + ++ virSetErrorFunc (NULL, ignore_errors); + r = virInitialize (); +- CHECK_ERROR (r == -1, NULL, "virInitialize"); ++ CHECK_ERROR (r == -1, "virInitialize"); + + CAMLreturn (Val_unit); + } +diff --git a/libvirt/libvirt_c_prologue.c b/libvirt/libvirt_c_prologue.c +index 7d9c0f5..bf972e9 100644 +--- a/libvirt/libvirt_c_prologue.c ++++ b/libvirt/libvirt_c_prologue.c +@@ -24,7 +24,7 @@ static char *Optstring_val (value strv); + typedef value (*Val_ptr_t) (void *); + static value Val_opt (void *ptr, Val_ptr_t Val_ptr); + /*static value option_default (value option, value deflt);*/ +-static void _raise_virterror (virConnectPtr conn, const char *fn) Noreturn; ++static void _raise_virterror (const char *fn) Noreturn; + static void not_supported (const char *fn) Noreturn; + static value Val_virterror (virErrorPtr err); + +@@ -43,8 +43,8 @@ static value Val_virterror (virErrorPtr err); + /* Check error condition from a libvirt function, and automatically raise + * an exception if one is found. + */ +-#define CHECK_ERROR(cond, conn, fn) \ +- do { if (cond) _raise_virterror (conn, fn); } while (0) ++#define CHECK_ERROR(cond, fn) \ ++ do { if (cond) _raise_virterror (fn); } while (0) + + /*----------------------------------------------------------------------*/ + +-- +2.3.1 + diff --git a/0001-Use-C99-standard-int64_t-instead-of-OCaml-defined-an.patch b/0001-Use-C99-standard-int64_t-instead-of-OCaml-defined-an.patch new file mode 100644 index 0000000..c00a75a --- /dev/null +++ b/0001-Use-C99-standard-int64_t-instead-of-OCaml-defined-an.patch @@ -0,0 +1,35 @@ +From 21ac993da0a187821e812fe7b5b31a426121a546 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Sat, 30 Aug 2014 19:10:19 +0100 +Subject: [PATCH] Use C99 standard int64_t instead of OCaml defined (and soon + to go) int64. + +--- + libvirt/libvirt_c_oneoffs.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/libvirt/libvirt_c_oneoffs.c b/libvirt/libvirt_c_oneoffs.c +index 3bb572f..06b3852 100644 +--- a/libvirt/libvirt_c_oneoffs.c ++++ b/libvirt/libvirt_c_oneoffs.c +@@ -140,7 +140,7 @@ ocaml_libvirt_connect_node_get_free_memory (value connv) + NONBLOCKING (r = virNodeGetFreeMemory (conn)); + CHECK_ERROR (r == 0, conn, "virNodeGetFreeMemory"); + +- rv = caml_copy_int64 ((int64) r); ++ rv = caml_copy_int64 ((int64_t) r); + CAMLreturn (rv); + } + +@@ -161,7 +161,7 @@ ocaml_libvirt_connect_node_get_cells_free_memory (value connv, + + rv = caml_alloc (r, 0); + for (i = 0; i < r; ++i) { +- iv = caml_copy_int64 ((int64) freemems[i]); ++ iv = caml_copy_int64 ((int64_t) freemems[i]); + Store_field (rv, i, iv); + } + +-- +2.0.4 + diff --git a/0001-Use-g-warn-error.patch b/0001-Use-g-warn-error.patch new file mode 100644 index 0000000..7c6bf35 --- /dev/null +++ b/0001-Use-g-warn-error.patch @@ -0,0 +1,78 @@ +From 2ba6898b4dc121b00078e36d5416b3caadd5d05e Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Mon, 27 Mar 2017 14:12:50 +0100 +Subject: [PATCH 1/5] Use -g -warn-error. + +Use -g for ocamlopt. ocamlopt has supported generating DWARF +information for quite a long time. + +Also use -warn-error with the same set of warnings as is used +by libguestfs. + +Fix a warning in examples/get_cpu_stats.ml found by enabling +-warn-error. +--- + examples/Makefile.in | 4 ++-- + examples/get_cpu_stats.ml | 2 ++ + libvirt/Makefile.in | 6 +++--- + 3 files changed, 7 insertions(+), 5 deletions(-) + +diff --git a/examples/Makefile.in b/examples/Makefile.in +index 041e382..46006a0 100644 +--- a/examples/Makefile.in ++++ b/examples/Makefile.in +@@ -18,10 +18,10 @@ + OCAMLFIND = @OCAMLFIND@ + + OCAMLCPACKAGES := -package unix -I ../libvirt +-OCAMLCFLAGS := -g ++OCAMLCFLAGS := -g -warn-error CDEFLMPSUVYZX-3 + OCAMLCLIBS := -linkpkg + OCAMLOPTPACKAGES := $(OCAMLCPACKAGES) +-OCAMLOPTFLAGS := ++OCAMLOPTFLAGS := -g -warn-error CDEFLMPSUVYZX-3 + OCAMLOPTLIBS := $(OCAMLCLIBS) + + export LIBRARY_PATH=../libvirt +diff --git a/examples/get_cpu_stats.ml b/examples/get_cpu_stats.ml +index d7a8d0c..814c85e 100644 +--- a/examples/get_cpu_stats.ml ++++ b/examples/get_cpu_stats.ml +@@ -19,9 +19,11 @@ let () = + + let conn = C.connect_readonly () in + ++ (* + let nr_pcpus = + let info = C.get_node_info conn in + C.maxcpus_of_node_info info in ++ *) + + let stats = + let dom = D.lookup_by_name conn domname in +diff --git a/libvirt/Makefile.in b/libvirt/Makefile.in +index f7c04bb..cf614fc 100644 +--- a/libvirt/Makefile.in ++++ b/libvirt/Makefile.in +@@ -31,15 +31,15 @@ OCAMLMKLIB = @OCAMLMKLIB@ + + ifneq ($(OCAMLFIND),) + OCAMLCPACKAGES := -package unix +-OCAMLCFLAGS := -g ++OCAMLCFLAGS := -g -warn-error CDEFLMPSUVYZX-3 + OCAMLCLIBS := -linkpkg + else + OCAMLCINCS := +-OCAMLCFLAGS := -g ++OCAMLCFLAGS := -g -warn-error CDEFLMPSUVYZX-3 + OCAMLCLIBS := unix.cma + endif + +-OCAMLOPTFLAGS := ++OCAMLOPTFLAGS := $(OCAMLCFLAGS) + ifneq ($(OCAMLFIND),) + OCAMLOPTPACKAGES := $(OCAMLCPACKAGES) + OCAMLOPTLIBS := $(OCAMLCLIBS) +-- +2.9.3 + diff --git a/0001-Use-safe-string-and-fix-the-library.patch b/0001-Use-safe-string-and-fix-the-library.patch new file mode 100644 index 0000000..448b08b --- /dev/null +++ b/0001-Use-safe-string-and-fix-the-library.patch @@ -0,0 +1,76 @@ +From bab7f84ade84ceaddb08b6948792d49b3d04b897 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Wed, 8 Nov 2017 16:52:58 +0000 +Subject: [PATCH] Use -safe-string and fix the library. + +Note this changes the type of the cpumap from string to bytes, +since (by the design of the API) it must be mutated. +--- + libvirt/Makefile.in | 4 ++-- + libvirt/libvirt.ml | 10 +++++----- + libvirt/libvirt.mli | 6 +++--- + 3 files changed, 10 insertions(+), 10 deletions(-) + +diff --git a/libvirt/Makefile.in b/libvirt/Makefile.in +index cf614fc..1eb846b 100644 +--- a/libvirt/Makefile.in ++++ b/libvirt/Makefile.in +@@ -31,11 +31,11 @@ OCAMLMKLIB = @OCAMLMKLIB@ + + ifneq ($(OCAMLFIND),) + OCAMLCPACKAGES := -package unix +-OCAMLCFLAGS := -g -warn-error CDEFLMPSUVYZX-3 ++OCAMLCFLAGS := -g -warn-error CDEFLMPSUVYZX-3 -safe-string + OCAMLCLIBS := -linkpkg + else + OCAMLCINCS := +-OCAMLCFLAGS := -g -warn-error CDEFLMPSUVYZX-3 ++OCAMLCFLAGS := -g -warn-error CDEFLMPSUVYZX-3 -safe-string + OCAMLCLIBS := unix.cma + endif + +diff --git a/libvirt/libvirt.ml b/libvirt/libvirt.ml +index d03a127..7e1e470 100644 +--- a/libvirt/libvirt.ml ++++ b/libvirt/libvirt.ml +@@ -92,13 +92,13 @@ struct + + (* See VIR_USE_CPU, VIR_UNUSE_CPU, VIR_CPU_USABLE macros defined in . *) + let use_cpu cpumap cpu = +- cpumap.[cpu/8] <- +- Char.chr (Char.code cpumap.[cpu/8] lor (1 lsl (cpu mod 8))) ++ Bytes.set cpumap (cpu/8) ++ (Char.chr (Char.code (Bytes.get cpumap (cpu/8)) lor (1 lsl (cpu mod 8)))) + let unuse_cpu cpumap cpu = +- cpumap.[cpu/8] <- +- Char.chr (Char.code cpumap.[cpu/8] land (lnot (1 lsl (cpu mod 8)))) ++ Bytes.set cpumap (cpu/8) ++ (Char.chr (Char.code (Bytes.get cpumap (cpu/8)) land (lnot (1 lsl (cpu mod 8))))) + let cpu_usable cpumaps maplen vcpu cpu = +- Char.code cpumaps.[vcpu*maplen + cpu/8] land (1 lsl (cpu mod 8)) <> 0 ++ Char.code (Bytes.get cpumaps (vcpu*maplen + cpu/8)) land (1 lsl (cpu mod 8)) <> 0 + + external set_keep_alive : [>`R] t -> int -> int -> unit = "ocaml_libvirt_connect_set_keep_alive" + +diff --git a/libvirt/libvirt.mli b/libvirt/libvirt.mli +index dc0033b..87f50f5 100644 +--- a/libvirt/libvirt.mli ++++ b/libvirt/libvirt.mli +@@ -376,11 +376,11 @@ sig + CPU map between a single virtual and all physical CPUs of a domain. + *) + +- val use_cpu : string -> int -> unit ++ val use_cpu : bytes -> int -> unit + (** [use_cpu cpumap cpu] marks [cpu] as usable in [cpumap]. *) +- val unuse_cpu : string -> int -> unit ++ val unuse_cpu : bytes -> int -> unit + (** [unuse_cpu cpumap cpu] marks [cpu] as not usable in [cpumap]. *) +- val cpu_usable : string -> int -> int -> int -> bool ++ val cpu_usable : bytes -> int -> int -> int -> bool + (** [cpu_usable cpumaps maplen vcpu cpu] checks returns true iff the + [cpu] is usable by [vcpu]. *) + +-- +2.13.1 + diff --git a/0002-Don-t-bother-checking-return-from-virInitialize.patch b/0002-Don-t-bother-checking-return-from-virInitialize.patch new file mode 100644 index 0000000..bbf01a6 --- /dev/null +++ b/0002-Don-t-bother-checking-return-from-virInitialize.patch @@ -0,0 +1,32 @@ +From 06b24089986523806d386b9e3cfa4fcf5eeb87e6 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 17 Mar 2015 12:53:29 +0000 +Subject: [PATCH 2/2] Don't bother checking return from virInitialize. + +The Perl bindings don't do this, and it seems that the call can never +fail, or if it does we don't care. +--- + libvirt/libvirt_c_oneoffs.c | 5 +---- + 1 file changed, 1 insertion(+), 4 deletions(-) + +diff --git a/libvirt/libvirt_c_oneoffs.c b/libvirt/libvirt_c_oneoffs.c +index 32e5a4b..5d82194 100644 +--- a/libvirt/libvirt_c_oneoffs.c ++++ b/libvirt/libvirt_c_oneoffs.c +@@ -1229,12 +1229,9 @@ CAMLprim value + ocaml_libvirt_init (value unit) + { + CAMLparam1 (unit); +- CAMLlocal1 (rv); +- int r; + + virSetErrorFunc (NULL, ignore_errors); +- r = virInitialize (); +- CHECK_ERROR (r == -1, "virInitialize"); ++ virInitialize (); + + CAMLreturn (Val_unit); + } +-- +2.3.1 + diff --git a/0002-Update-dependencies.patch b/0002-Update-dependencies.patch new file mode 100644 index 0000000..1ba95ea --- /dev/null +++ b/0002-Update-dependencies.patch @@ -0,0 +1,44 @@ +From ca9a3227f9937f9cdeb84126f1c74502c9a25047 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Mon, 27 Mar 2017 14:13:47 +0100 +Subject: [PATCH 2/5] Update dependencies. + +--- + examples/.depend | 8 ++++---- + libvirt/.depend | 6 +++--- + 2 files changed, 7 insertions(+), 7 deletions(-) + +diff --git a/examples/.depend b/examples/.depend +index b305b76..b5379d8 100644 +--- a/examples/.depend ++++ b/examples/.depend +@@ -1,8 +1,8 @@ +-node_info.cmo : ../libvirt/libvirt.cmi +-node_info.cmx : ../libvirt/libvirt.cmx +-get_cpu_stats.cmo : ../libvirt/libvirt.cmi +-get_cpu_stats.cmx : ../libvirt/libvirt.cmx + domain_events.cmo : ../libvirt/libvirt.cmi + domain_events.cmx : ../libvirt/libvirt.cmx ++get_cpu_stats.cmo : ../libvirt/libvirt.cmi ++get_cpu_stats.cmx : ../libvirt/libvirt.cmx + list_domains.cmo : ../libvirt/libvirt.cmi + list_domains.cmx : ../libvirt/libvirt.cmx ++node_info.cmo : ../libvirt/libvirt.cmi ++node_info.cmx : ../libvirt/libvirt.cmx +diff --git a/libvirt/.depend b/libvirt/.depend +index 7d32e13..ee1180c 100644 +--- a/libvirt/.depend ++++ b/libvirt/.depend +@@ -1,6 +1,6 @@ +-libvirt_version.cmi : ++libvirt.cmo : libvirt.cmi ++libvirt.cmx : libvirt.cmi + libvirt.cmi : + libvirt_version.cmo : libvirt_version.cmi + libvirt_version.cmx : libvirt_version.cmi +-libvirt.cmo : libvirt.cmi +-libvirt.cmx : libvirt.cmi ++libvirt_version.cmi : +-- +2.9.3 + diff --git a/0003-Add-a-binding-for-virConnectGetAllDomainStats-RHBZ-1.patch b/0003-Add-a-binding-for-virConnectGetAllDomainStats-RHBZ-1.patch new file mode 100644 index 0000000..0eb1b28 --- /dev/null +++ b/0003-Add-a-binding-for-virConnectGetAllDomainStats-RHBZ-1.patch @@ -0,0 +1,393 @@ +From 380f1e05b244ae4750ca5101b5b5a182dcd0d1fd Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 28 Mar 2017 10:08:06 +0100 +Subject: [PATCH 3/5] Add a binding for virConnectGetAllDomainStats + (RHBZ#1390171). + +--- + .gitignore | 2 + + Makefile.in | 1 + + examples/.depend | 2 + + examples/Makefile.in | 13 ++++- + examples/get_all_domain_stats.ml | 65 +++++++++++++++++++++ + libvirt/libvirt.ml | 23 ++++++++ + libvirt/libvirt.mli | 28 +++++++++ + libvirt/libvirt_c_oneoffs.c | 119 ++++++++++++++++++++++++++++++++++++++- + 8 files changed, 250 insertions(+), 3 deletions(-) + create mode 100644 examples/get_all_domain_stats.ml + +diff --git a/.gitignore b/.gitignore +index 71a245e..366eb29 100644 +--- a/.gitignore ++++ b/.gitignore +@@ -1,3 +1,4 @@ ++.gdb_history + META + ocaml-libvirt-*.tar.gz + ocaml-libvirt-*.exe +@@ -27,6 +28,7 @@ core.* + *~ + libvirt/libvirt_version.ml + examples/domain_events ++examples/get_all_domain_stats + examples/get_cpu_stats + examples/list_domains + examples/node_info +diff --git a/Makefile.in b/Makefile.in +index 3b8b7ec..2605ddd 100644 +--- a/Makefile.in ++++ b/Makefile.in +@@ -41,6 +41,7 @@ clean: + rm -f examples/node_info + rm -f examples/get_cpu_stats + rm -f examples/domain_events ++ rm -f examples/get_all_domain_stats + + distclean: clean + rm -f config.h config.log config.status configure +diff --git a/examples/.depend b/examples/.depend +index b5379d8..11f2c7c 100644 +--- a/examples/.depend ++++ b/examples/.depend +@@ -1,5 +1,7 @@ + domain_events.cmo : ../libvirt/libvirt.cmi + domain_events.cmx : ../libvirt/libvirt.cmx ++get_all_domain_stats.cmo : ../libvirt/libvirt.cmi ++get_all_domain_stats.cmx : ../libvirt/libvirt.cmx + get_cpu_stats.cmo : ../libvirt/libvirt.cmi + get_cpu_stats.cmx : ../libvirt/libvirt.cmx + list_domains.cmo : ../libvirt/libvirt.cmi +diff --git a/examples/Makefile.in b/examples/Makefile.in +index 46006a0..8530edc 100644 +--- a/examples/Makefile.in ++++ b/examples/Makefile.in +@@ -27,7 +27,8 @@ OCAMLOPTLIBS := $(OCAMLCLIBS) + export LIBRARY_PATH=../libvirt + export LD_LIBRARY_PATH=../libvirt + +-BYTE_TARGETS := list_domains node_info get_cpu_stats domain_events ++BYTE_TARGETS := list_domains node_info get_cpu_stats \ ++ get_all_domain_stats domain_events + OPT_TARGETS := $(BYTE_TARGETS:%=%.opt) + + all: $(BYTE_TARGETS) +@@ -64,6 +65,16 @@ get_cpu_stats.opt: get_cpu_stats.cmx + $(OCAMLOPTPACKAGES) $(OCAMLOPTFLAGS) $(OCAMLOPTLIBS) \ + ../libvirt/mllibvirt.cmxa -o $@ $< + ++get_all_domain_stats: get_all_domain_stats.cmo ++ $(OCAMLFIND) ocamlc \ ++ $(OCAMLCPACKAGES) $(OCAMLCFLAGS) $(OCAMLCLIBS) \ ++ ../libvirt/mllibvirt.cma -o $@ $< ++ ++get_all_domain_stats.opt: get_all_domain_stats.cmx ++ $(OCAMLFIND) ocamlopt \ ++ $(OCAMLOPTPACKAGES) $(OCAMLOPTFLAGS) $(OCAMLOPTLIBS) \ ++ ../libvirt/mllibvirt.cmxa -o $@ $< ++ + domain_events: domain_events.cmo + $(OCAMLFIND) ocamlc \ + $(OCAMLCPACKAGES) $(OCAMLCFLAGS) $(OCAMLCLIBS) \ +diff --git a/examples/get_all_domain_stats.ml b/examples/get_all_domain_stats.ml +new file mode 100644 +index 0000000..4375639 +--- /dev/null ++++ b/examples/get_all_domain_stats.ml +@@ -0,0 +1,65 @@ ++(* Example of using Domain.get_all_domain_stats (virConnectGetAllDomainStats). ++ * Usage: get_all_domain_stats ++ * http://libvirt.org/ ++ *) ++ ++open Printf ++ ++module C = Libvirt.Connect ++module D = Libvirt.Domain ++ ++let print_stats stats = ++ try ++ Array.iter ( ++ fun { D.dom = dom; D.params = params } -> ++ printf "domain %s:\n" (D.get_name dom); ++ Array.iteri ( ++ fun i (field, value) -> ++ printf "\t%-20s = " field; ++ (match value with ++ | D.TypedFieldInt32 i -> printf "%ld" i ++ | D.TypedFieldUInt32 i -> printf "%ld" i ++ | D.TypedFieldInt64 i -> printf "%Ld" i ++ | D.TypedFieldUInt64 i -> printf "%Ld" i ++ | D.TypedFieldFloat f -> printf "%g" f ++ | D.TypedFieldBool b -> printf "%b" b ++ | D.TypedFieldString s -> printf "%S" s); ++ printf "\n"; ++ ) params; ++ printf "\n" ++ ) stats ++ with ++ Libvirt.Virterror err -> ++ eprintf "error: %s\n" (Libvirt.Virterror.to_string err) ++ ++let () = ++ if Array.length Sys.argv <> 1 then ( ++ eprintf "error: get_all_domain_stats\n"; ++ exit 1 ++ ); ++ ++ let conn = C.connect_readonly () in ++ ++ let what_stats = [D.StatsCpuTotal; D.StatsInterface; D.StatsBlock] in ++ let flags = [D.GetAllDomainsStatsActive; D.GetAllDomainsStatsInactive] in ++ ++ let quit = ref false in ++ ++ while not !quit do ++ let stats = D.get_all_domain_stats conn what_stats flags in ++ ++ if stats <> [||] then print_stats stats ++ else ( ++ printf "no guests found\n"; ++ quit := true ++ ); ++ flush stdout; ++ ++ (* Run the garbage collector which is a good way to check for ++ * memory corruption errors and reference counting issues in ++ * libvirt. You shouldn't do this in ordinary programs. ++ *) ++ Gc.compact (); ++ ++ if not !quit then Unix.sleep 3 ++ done +diff --git a/libvirt/libvirt.ml b/libvirt/libvirt.ml +index 1be023d..ce1878a 100644 +--- a/libvirt/libvirt.ml ++++ b/libvirt/libvirt.ml +@@ -392,6 +392,27 @@ struct + tx_drop : int64; + } + ++ type get_all_domain_stats_flag = ++ | GetAllDomainsStatsActive ++ | GetAllDomainsStatsInactive ++ | GetAllDomainsStatsOther ++ | GetAllDomainsStatsPaused ++ | GetAllDomainsStatsPersistent ++ | GetAllDomainsStatsRunning ++ | GetAllDomainsStatsShutoff ++ | GetAllDomainsStatsTransient ++ | GetAllDomainsStatsBacking ++ | GetAllDomainsStatsEnforceStats ++ ++ type stats_type = ++ | StatsState | StatsCpuTotal | StatsBalloon | StatsVcpu ++ | StatsInterface | StatsBlock | StatsPerf ++ ++ type 'a domain_stats_record = { ++ dom : 'a t; ++ params : typed_param array; ++ } ++ + (* The maximum size for Domain.memory_peek and Domain.block_peek + * supported by libvirt. This may change with different versions + * of libvirt in the future, hence it's a function. +@@ -446,6 +467,8 @@ struct + external block_peek : [>`W] t -> string -> int64 -> int -> string -> int -> unit = "ocaml_libvirt_domain_block_peek_bytecode" "ocaml_libvirt_domain_block_peek_native" + external memory_peek : [>`W] t -> memory_flag list -> int64 -> int -> string -> int -> unit = "ocaml_libvirt_domain_memory_peek_bytecode" "ocaml_libvirt_domain_memory_peek_native" + ++ external get_all_domain_stats : 'a Connect.t -> stats_type list -> get_all_domain_stats_flag list -> 'a domain_stats_record array = "ocaml_libvirt_domain_get_all_domain_stats" ++ + external const : [>`R] t -> ro t = "%identity" + + let get_domains conn flags = +diff --git a/libvirt/libvirt.mli b/libvirt/libvirt.mli +index 8cfcae2..d1b5992 100644 +--- a/libvirt/libvirt.mli ++++ b/libvirt/libvirt.mli +@@ -478,6 +478,27 @@ sig + tx_drop : int64; + } + ++ type get_all_domain_stats_flag = ++ | GetAllDomainsStatsActive ++ | GetAllDomainsStatsInactive ++ | GetAllDomainsStatsOther ++ | GetAllDomainsStatsPaused ++ | GetAllDomainsStatsPersistent ++ | GetAllDomainsStatsRunning ++ | GetAllDomainsStatsShutoff ++ | GetAllDomainsStatsTransient ++ | GetAllDomainsStatsBacking ++ | GetAllDomainsStatsEnforceStats ++ ++ type stats_type = ++ | StatsState | StatsCpuTotal | StatsBalloon | StatsVcpu ++ | StatsInterface | StatsBlock | StatsPerf ++ ++ type 'a domain_stats_record = { ++ dom : 'a t; ++ params : typed_param array; ++ } ++ + val max_peek : [>`R] t -> int + (** Maximum size supported by the {!block_peek} and {!memory_peek} + functions. If you want to peek more than this then you must +@@ -615,6 +636,13 @@ sig + + See also {!max_peek}. *) + ++ external get_all_domain_stats : 'a Connect.t -> stats_type list -> get_all_domain_stats_flag list -> 'a domain_stats_record array = "ocaml_libvirt_domain_get_all_domain_stats" ++ (** [get_all_domain_stats conn stats flags] allows you to read ++ all stats across multiple/all domains in a single call. ++ ++ See the libvirt documentation for ++ [virConnectGetAllDomainStats]. *) ++ + external const : [>`R] t -> ro t = "%identity" + (** [const dom] turns a read/write domain handle into a read-only + domain handle. Note that the opposite operation is impossible. +diff --git a/libvirt/libvirt_c_oneoffs.c b/libvirt/libvirt_c_oneoffs.c +index 5d82194..17412f5 100644 +--- a/libvirt/libvirt_c_oneoffs.c ++++ b/libvirt/libvirt_c_oneoffs.c +@@ -1,5 +1,5 @@ + /* OCaml bindings for libvirt. +- * (C) Copyright 2007 Richard W.M. Jones, Red Hat Inc. ++ * (C) Copyright 2007-2017 Richard W.M. Jones, Red Hat Inc. + * http://libvirt.org/ + * + * This library is free software; you can redistribute it and/or +@@ -184,7 +184,6 @@ ocaml_libvirt_connect_set_keep_alive(value connv, + CAMLreturn(Val_unit); + } + +- + CAMLprim value + ocaml_libvirt_domain_get_id (value domv) + { +@@ -560,6 +559,122 @@ ocaml_libvirt_domain_get_cpu_stats (value domv) + CAMLreturn (cpustats); + } + ++value ++ocaml_libvirt_domain_get_all_domain_stats (value connv, ++ value statsv, value flagsv) ++{ ++ CAMLparam3 (connv, statsv, flagsv); ++ CAMLlocal5 (rv, dsv, tpv, v, v1); ++ CAMLlocal1 (v2); ++ virConnectPtr conn = Connect_val (connv); ++ virDomainStatsRecordPtr *rstats; ++ unsigned int stats = 0, flags = 0; ++ int i, j, r; ++ ++ /* Get stats and flags. */ ++ for (; statsv != Val_int (0); statsv = Field (statsv, 1)) { ++ v = Field (statsv, 0); ++ if (v == Val_int (0)) ++ stats |= VIR_DOMAIN_STATS_STATE; ++ else if (v == Val_int (1)) ++ stats |= VIR_DOMAIN_STATS_CPU_TOTAL; ++ else if (v == Val_int (2)) ++ stats |= VIR_DOMAIN_STATS_BALLOON; ++ else if (v == Val_int (3)) ++ stats |= VIR_DOMAIN_STATS_VCPU; ++ else if (v == Val_int (4)) ++ stats |= VIR_DOMAIN_STATS_INTERFACE; ++ else if (v == Val_int (5)) ++ stats |= VIR_DOMAIN_STATS_BLOCK; ++ else if (v == Val_int (6)) ++ stats |= VIR_DOMAIN_STATS_PERF; ++ } ++ for (; flagsv != Val_int (0); flagsv = Field (flagsv, 1)) { ++ v = Field (flagsv, 0); ++ if (v == Val_int (0)) ++ flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_ACTIVE; ++ else if (v == Val_int (1)) ++ flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_INACTIVE; ++ else if (v == Val_int (2)) ++ flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER; ++ else if (v == Val_int (3)) ++ flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED; ++ else if (v == Val_int (4)) ++ flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_PERSISTENT; ++ else if (v == Val_int (5)) ++ flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING; ++ else if (v == Val_int (6)) ++ flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF; ++ else if (v == Val_int (7)) ++ flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT; ++ else if (v == Val_int (8)) ++ flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_BACKING; ++ else if (v == Val_int (9)) ++ flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS; ++ } ++ ++ NONBLOCKING (r = virConnectGetAllDomainStats (conn, stats, &rstats, flags)); ++ CHECK_ERROR (r == -1, "virConnectGetAllDomainStats"); ++ ++ rv = caml_alloc (r, 0); /* domain_stats_record array. */ ++ for (i = 0; i < r; ++i) { ++ dsv = caml_alloc (2, 0); /* domain_stats_record */ ++ virDomainRef (rstats[i]->dom); ++ Store_field (dsv, 0, Val_domain (rstats[i]->dom, connv)); ++ ++ tpv = caml_alloc (rstats[i]->nparams, 0); /* typed_param array */ ++ for (j = 0; j < rstats[i]->nparams; ++j) { ++ v2 = caml_alloc (2, 0); /* typed_param: field name, value */ ++ Store_field (v2, 0, caml_copy_string (rstats[i]->params[j].field)); ++ ++ switch (rstats[i]->params[j].type) { ++ case VIR_TYPED_PARAM_INT: ++ v1 = caml_alloc (1, 0); ++ v = caml_copy_int32 (rstats[i]->params[j].value.i); ++ break; ++ case VIR_TYPED_PARAM_UINT: ++ v1 = caml_alloc (1, 1); ++ v = caml_copy_int32 (rstats[i]->params[j].value.ui); ++ break; ++ case VIR_TYPED_PARAM_LLONG: ++ v1 = caml_alloc (1, 2); ++ v = caml_copy_int64 (rstats[i]->params[j].value.l); ++ break; ++ case VIR_TYPED_PARAM_ULLONG: ++ v1 = caml_alloc (1, 3); ++ v = caml_copy_int64 (rstats[i]->params[j].value.ul); ++ break; ++ case VIR_TYPED_PARAM_DOUBLE: ++ v1 = caml_alloc (1, 4); ++ v = caml_copy_double (rstats[i]->params[j].value.d); ++ break; ++ case VIR_TYPED_PARAM_BOOLEAN: ++ v1 = caml_alloc (1, 5); ++ v = Val_bool (rstats[i]->params[j].value.b); ++ break; ++ case VIR_TYPED_PARAM_STRING: ++ v1 = caml_alloc (1, 6); ++ v = caml_copy_string (rstats[i]->params[j].value.s); ++ break; ++ default: ++ virDomainStatsRecordListFree (rstats); ++ caml_failwith ("virConnectGetAllDomainStats: " ++ "unknown parameter type returned"); ++ } ++ Store_field (v1, 0, v); ++ ++ Store_field (v2, 1, v1); ++ Store_field (tpv, j, v2); ++ } ++ ++ Store_field (dsv, 1, tpv); ++ Store_field (rv, i, dsv); ++ } ++ ++ virDomainStatsRecordListFree (rstats); ++ CAMLreturn (rv); ++} ++ + CAMLprim value + ocaml_libvirt_domain_migrate_native (value domv, value dconnv, value flagsv, value optdnamev, value opturiv, value optbandwidthv, value unitv) + { +-- +2.9.3 + diff --git a/0004-examples-Print-more-stats-in-the-get_all_domain_stat.patch b/0004-examples-Print-more-stats-in-the-get_all_domain_stat.patch new file mode 100644 index 0000000..a4baded --- /dev/null +++ b/0004-examples-Print-more-stats-in-the-get_all_domain_stat.patch @@ -0,0 +1,42 @@ +From 2bb6200934090f34f81d1badb9a55f5a86a7fb32 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 28 Mar 2017 13:11:09 +0100 +Subject: [PATCH 4/5] examples: Print more stats in the get_all_domain_stats.ml + example. + +Updates commit 380f1e05b244ae4750ca5101b5b5a182dcd0d1fd. +--- + examples/get_all_domain_stats.ml | 13 ++++++++++--- + 1 file changed, 10 insertions(+), 3 deletions(-) + +diff --git a/examples/get_all_domain_stats.ml b/examples/get_all_domain_stats.ml +index 4375639..cc86da6 100644 +--- a/examples/get_all_domain_stats.ml ++++ b/examples/get_all_domain_stats.ml +@@ -40,13 +40,20 @@ let () = + + let conn = C.connect_readonly () in + +- let what_stats = [D.StatsCpuTotal; D.StatsInterface; D.StatsBlock] in +- let flags = [D.GetAllDomainsStatsActive; D.GetAllDomainsStatsInactive] in ++ let what = [ ++ D.StatsState; ++ D.StatsCpuTotal; ++ D.StatsBalloon; ++ D.StatsVcpu; ++ D.StatsInterface; ++ D.StatsBlock; ++ ] in ++ let who = [] in (* empty list means returns all domains *) + + let quit = ref false in + + while not !quit do +- let stats = D.get_all_domain_stats conn what_stats flags in ++ let stats = D.get_all_domain_stats conn what who in + + if stats <> [||] then print_stats stats + else ( +-- +2.9.3 + diff --git a/0005-Change-binding-of-virConnectGetAllDomainStats-to-ret.patch b/0005-Change-binding-of-virConnectGetAllDomainStats-to-ret.patch new file mode 100644 index 0000000..955a4ca --- /dev/null +++ b/0005-Change-binding-of-virConnectGetAllDomainStats-to-ret.patch @@ -0,0 +1,127 @@ +From 3169af3337938e18bf9ecc6ce936d644e14ff3de Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 28 Mar 2017 13:52:51 +0100 +Subject: [PATCH 5/5] Change binding of virConnectGetAllDomainStats to return + dom UUID. + +The virDomainPtr object returned by this binding isn't a reliable +virDomainPtr object. The only thing we can safely do with it is to +get its UUID. Modify the API correspondingly. + +Updates commit 380f1e05b244ae4750ca5101b5b5a182dcd0d1fd. +--- + examples/get_all_domain_stats.ml | 7 ++++--- + libvirt/libvirt.ml | 6 +++--- + libvirt/libvirt.mli | 6 +++--- + libvirt/libvirt_c_oneoffs.c | 13 +++++++++++-- + 4 files changed, 21 insertions(+), 11 deletions(-) + +diff --git a/examples/get_all_domain_stats.ml b/examples/get_all_domain_stats.ml +index cc86da6..be91f77 100644 +--- a/examples/get_all_domain_stats.ml ++++ b/examples/get_all_domain_stats.ml +@@ -8,10 +8,11 @@ open Printf + module C = Libvirt.Connect + module D = Libvirt.Domain + +-let print_stats stats = ++let print_stats conn stats = + try + Array.iter ( +- fun { D.dom = dom; D.params = params } -> ++ fun { D.dom_uuid = uuid; D.params = params } -> ++ let dom = D.lookup_by_uuid conn uuid in + printf "domain %s:\n" (D.get_name dom); + Array.iteri ( + fun i (field, value) -> +@@ -55,7 +56,7 @@ let () = + while not !quit do + let stats = D.get_all_domain_stats conn what who in + +- if stats <> [||] then print_stats stats ++ if stats <> [||] then print_stats conn stats + else ( + printf "no guests found\n"; + quit := true +diff --git a/libvirt/libvirt.ml b/libvirt/libvirt.ml +index ce1878a..d03a127 100644 +--- a/libvirt/libvirt.ml ++++ b/libvirt/libvirt.ml +@@ -408,8 +408,8 @@ struct + | StatsState | StatsCpuTotal | StatsBalloon | StatsVcpu + | StatsInterface | StatsBlock | StatsPerf + +- type 'a domain_stats_record = { +- dom : 'a t; ++ type domain_stats_record = { ++ dom_uuid : uuid; + params : typed_param array; + } + +@@ -467,7 +467,7 @@ struct + external block_peek : [>`W] t -> string -> int64 -> int -> string -> int -> unit = "ocaml_libvirt_domain_block_peek_bytecode" "ocaml_libvirt_domain_block_peek_native" + external memory_peek : [>`W] t -> memory_flag list -> int64 -> int -> string -> int -> unit = "ocaml_libvirt_domain_memory_peek_bytecode" "ocaml_libvirt_domain_memory_peek_native" + +- external get_all_domain_stats : 'a Connect.t -> stats_type list -> get_all_domain_stats_flag list -> 'a domain_stats_record array = "ocaml_libvirt_domain_get_all_domain_stats" ++ external get_all_domain_stats : [>`R] Connect.t -> stats_type list -> get_all_domain_stats_flag list -> domain_stats_record array = "ocaml_libvirt_domain_get_all_domain_stats" + + external const : [>`R] t -> ro t = "%identity" + +diff --git a/libvirt/libvirt.mli b/libvirt/libvirt.mli +index d1b5992..dc0033b 100644 +--- a/libvirt/libvirt.mli ++++ b/libvirt/libvirt.mli +@@ -494,8 +494,8 @@ sig + | StatsState | StatsCpuTotal | StatsBalloon | StatsVcpu + | StatsInterface | StatsBlock | StatsPerf + +- type 'a domain_stats_record = { +- dom : 'a t; ++ type domain_stats_record = { ++ dom_uuid : uuid; + params : typed_param array; + } + +@@ -636,7 +636,7 @@ sig + + See also {!max_peek}. *) + +- external get_all_domain_stats : 'a Connect.t -> stats_type list -> get_all_domain_stats_flag list -> 'a domain_stats_record array = "ocaml_libvirt_domain_get_all_domain_stats" ++ external get_all_domain_stats : [>`R] Connect.t -> stats_type list -> get_all_domain_stats_flag list -> domain_stats_record array = "ocaml_libvirt_domain_get_all_domain_stats" + (** [get_all_domain_stats conn stats flags] allows you to read + all stats across multiple/all domains in a single call. + +diff --git a/libvirt/libvirt_c_oneoffs.c b/libvirt/libvirt_c_oneoffs.c +index 17412f5..958ba69 100644 +--- a/libvirt/libvirt_c_oneoffs.c ++++ b/libvirt/libvirt_c_oneoffs.c +@@ -570,6 +570,7 @@ ocaml_libvirt_domain_get_all_domain_stats (value connv, + virDomainStatsRecordPtr *rstats; + unsigned int stats = 0, flags = 0; + int i, j, r; ++ unsigned char uuid[VIR_UUID_BUFLEN]; + + /* Get stats and flags. */ + for (; statsv != Val_int (0); statsv = Field (statsv, 1)) { +@@ -619,8 +620,16 @@ ocaml_libvirt_domain_get_all_domain_stats (value connv, + rv = caml_alloc (r, 0); /* domain_stats_record array. */ + for (i = 0; i < r; ++i) { + dsv = caml_alloc (2, 0); /* domain_stats_record */ +- virDomainRef (rstats[i]->dom); +- Store_field (dsv, 0, Val_domain (rstats[i]->dom, connv)); ++ ++ /* Libvirt returns something superficially resembling a ++ * virDomainPtr, but it's not a real virDomainPtr object ++ * (eg. dom->id == -1, and its refcount is wrong). The only thing ++ * we can safely get from it is the UUID. ++ */ ++ v = caml_alloc_string (VIR_UUID_BUFLEN); ++ virDomainGetUUID (rstats[i]->dom, uuid); ++ memcpy (String_val (v), uuid, VIR_UUID_BUFLEN); ++ Store_field (dsv, 0, v); + + tpv = caml_alloc (rstats[i]->nparams, 0); /* typed_param array */ + for (j = 0; j < rstats[i]->nparams; ++j) { +-- +2.9.3 + diff --git a/ocaml-libvirt-0.6.1.4.tar.gz b/ocaml-libvirt-0.6.1.4.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..75ea1ec67e6f6b7735aece7102121b6fb7815e90 GIT binary patch literal 136023 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
Fy4bdaBSYd+}+cWuh3Rvu~c%A|q?V(>Rbby-A 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 literal 0 HcmV?d00001 diff --git a/ocaml-libvirt.spec b/ocaml-libvirt.spec new file mode 100644 index 0000000..5be393a --- /dev/null +++ b/ocaml-libvirt.spec @@ -0,0 +1,84 @@ +Name: ocaml-libvirt +Version: 0.6.1.4 +Release: 30 +Summary: OCaml binding for libvirt +License: LGPLv2+ + +URL: http://libvirt.org/ocaml/ +Source0: http://libvirt.org/sources/ocaml/%{name}-%{version}.tar.gz + +# Upstream patch to fix int types. +Patch0001: 0001-Use-C99-standard-int64_t-instead-of-OCaml-defined-an.patch + +# Upstream patch to add virDomainCreateXML binding. +Patch0002: 0001-Add-a-binding-for-virDomainCreateXML.patch + +# Upstream patches to fix error handling. +Patch0003: 0001-Suppress-errors-to-stderr-and-use-thread-local-virEr.patch +Patch0004: 0002-Don-t-bother-checking-return-from-virInitialize.patch + +# Upstream patch to remove unused function. +Patch0005: 0001-Remove-unused-not_supported-function.patch + +# Upstream patches to tidy up warnings. +Patch0006: 0001-Use-g-warn-error.patch +Patch0007: 0002-Update-dependencies.patch + +# Upstream patches to add binding for virConnectGetAllDomainStats. +Patch0008: 0003-Add-a-binding-for-virConnectGetAllDomainStats-RHBZ-1.patch +Patch0009: 0004-examples-Print-more-stats-in-the-get_all_domain_stat.patch +Patch0010: 0005-Change-binding-of-virConnectGetAllDomainStats-to-ret.patch + +# Upstream patch to use -safe-string. +Patch0011: 0001-Use-safe-string-and-fix-the-library.patch + +BuildRequires: ocaml >= 3.10.0 ocaml-ocamldoc ocaml-findlib-devel +BuildRequires: libvirt-devel >= 0.2.1 perl-interpreter gawk + +%description +OCaml bindings for libvirt, allowing you to write OCaml programs and scripts which control virtualisation features. + +%package devel +Summary: Development files for ocaml-libvirt +Requires: %{name} = %{version}-%{release} + + +%description devel +OCaml bindings for libvirt, allowing you to write OCaml programs and scripts which control virtualisation features. + + +%prep +%autosetup -n %{name}-%{version} -p1 + + +%build +%configure +%make_build all doc +%make_build opt + + +%install +export DESTDIR=$RPM_BUILD_ROOT +export OCAMLFIND_DESTDIR=$RPM_BUILD_ROOT%{_libdir}/ocaml +install -d $OCAMLFIND_DESTDIR $OCAMLFIND_DESTDIR/stublibs +install -d $RPM_BUILD_ROOT%{_bindir} +make install-opt + + +%files +%doc COPYING.LIB README ChangeLog +%{_libdir}/ocaml/libvirt +%exclude %{_libdir}/ocaml/libvirt/{*.a,*.cmxa,*.cmx,*.mli} +%{_libdir}/ocaml/stublibs/{*.so,*.so.owner} + + +%files devel +%doc COPYING.LIB README TODO.libvirt ChangeLog html/* +%{_libdir}/ocaml/libvirt/{*.a,*.cmxa,*.cmx,*.mli} + + +%changelog +* Tue Feb 18 2020 chenli - 0.6.1.4-30 +- Init Package. + +