ruby-libvirt 0.2.0 → 0.3.0

data/ext/libvirt/connect.h

@@ -1,7 +1,6 @@
 #ifndef CONNECT_H
 #define CONNECT_H
 
-extern VALUE c_connect;
 void init_connect();
 
 virConnectPtr conn(VALUE s);

data/ext/libvirt/domain.c

@@ -20,6 +20,9 @@
 
 #include <ruby.h>
 #include <libvirt/libvirt.h>
+#if HAVE_VIRDOMAINQEMUMONITORCOMMAND
+#include <libvirt/libvirt-qemu.h>
+#endif
 #include <libvirt/virterror.h>
 #include "common.h"
 #include "connect.h"
@@ -42,233 +45,27 @@ static VALUE c_domain_snapshot;
 #if HAVE_TYPE_VIRDOMAINJOBINFOPTR
 static VALUE c_domain_job_info;
 #endif
+static VALUE c_domain_vcpuinfo;
 
-static void domain_free(void *d) {
+void domain_free(void *d) {
     generic_free(Domain, d);
 }
 
-static VALUE domain_new(virDomainPtr d, VALUE conn) {
+VALUE domain_new(virDomainPtr d, VALUE conn) {
     return generic_new(c_domain, d, conn, domain_free);
 }
 
-static virDomainPtr domain_get(VALUE s) {
+virDomainPtr domain_get(VALUE s) {
     generic_get(Domain, s);
 }
 
 /*
  * call-seq:
- *   conn.num_of_domains -> fixnum
- *
- * Call +virConnectNumOfDomains+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDomains]
- */
-static VALUE libvirt_conn_num_of_domains(VALUE s) {
-    gen_conn_num_of(s, Domains);
-}
-
-/*
- * call-seq:
- *   conn.list_domains -> list
- *
- * Call +virConnectListDomains+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDomains]
- */
-static VALUE libvirt_conn_list_domains(VALUE s) {
-    int i, r, num, *ids;
-    virConnectPtr conn = connect_get(s);
-    VALUE result;
-
-    num = virConnectNumOfDomains(conn);
-    _E(num < 0, create_error(e_RetrieveError, "virConnectNumOfDomains", "", conn));
-    if (num == 0) {
-        result = rb_ary_new2(num);
-        return result;
-    }
-
-    ids = ALLOC_N(int, num);
-    r = virConnectListDomains(conn, ids, num);
-    if (r < 0) {
-        free(ids);
-        _E(r < 0, create_error(e_RetrieveError, "virConnectListDomains", "", conn));
-    }
-
-    result = rb_ary_new2(num);
-    for (i=0; i<num; i++) {
-        rb_ary_push(result, INT2NUM(ids[i]));
-    }
-    free(ids);
-    return result;
-}
-
-/*
- * call-seq:
- *   conn.num_of_defined_domains -> fixnum
- *
- * Call +virConnectNumOfDefinedDomains+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedDomains]
- */
-static VALUE libvirt_conn_num_of_defined_domains(VALUE s) {
-    gen_conn_num_of(s, DefinedDomains);
-}
-
-/*
- * call-seq:
- *   conn.list_defined_domains -> list
- *
- * Call +virConnectListDefinedDomains+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedDomains]
- */
-static VALUE libvirt_conn_list_defined_domains(VALUE s) {
-    gen_conn_list_names(s, DefinedDomains);
-}
-
-/*
- * call-seq:
- *   dom.create_linux -> Libvirt::Domain
- *
- * Call +virDomainCreateLinux+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCreateLinux]
- */
-static VALUE libvirt_conn_create_linux(int argc, VALUE *argv, VALUE c) {
-    virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
-    VALUE flags, xml;
-
-    rb_scan_args(argc, argv, "11", &xml, &flags);
-
-    if (NIL_P(flags))
-        flags = INT2FIX(0);
-
-    dom = virDomainCreateLinux(conn, StringValueCStr(xml), NUM2UINT(flags));
-    _E(dom == NULL, create_error(e_Error, "virDomainCreateLinux", "", conn));
-
-    return domain_new(dom, c);
-}
-
-/*
- * call-seq:
- *   conn.lookup_domain_by_name -> Libvirt::Domain
- *
- * Call +virDomainLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByName]
- */
-static VALUE libvirt_conn_lookup_domain_by_name(VALUE c, VALUE name) {
-    virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
-
-    dom = virDomainLookupByName(conn, StringValueCStr(name));
-    _E(dom == NULL, create_error(e_RetrieveError, "virDomainLookupByName", "", conn));
-
-    return domain_new(dom, c);
-}
-
-/*
- * call-seq:
- *   conn.lookup_domain_by_id -> Libvirt::Domain
- *
- * Call +virDomainLookupByID+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByID]
- */
-static VALUE libvirt_conn_lookup_domain_by_id(VALUE c, VALUE id) {
-    virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
-
-    dom = virDomainLookupByID(conn, NUM2INT(id));
-    _E(dom == NULL, create_error(e_RetrieveError, "virDomainLookupByID", "", conn));
-
-    return domain_new(dom, c);
-}
-
-/*
- * call-seq:
- *   conn.lookup_domain_by_uuid -> Libvirt::Domain
- *
- * Call +virDomainLookupByUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByUUIDString]
- */
-static VALUE libvirt_conn_lookup_domain_by_uuid(VALUE c, VALUE uuid) {
-    virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
-
-    dom = virDomainLookupByUUIDString(conn, StringValueCStr(uuid));
-    _E(dom == NULL, create_error(e_RetrieveError, "virDomainLookupByUUID", "", conn));
-
-    return domain_new(dom, c);
-}
-
-/*
- * call-seq:
- *   conn.define_domain_xml -> Libvirt::Domain
- *
- * Call +virDomainDefineXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainDefineXML]
- */
-static VALUE libvirt_conn_define_domain_xml(VALUE c, VALUE xml) {
-    virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
-
-    dom = virDomainDefineXML(conn, StringValueCStr(xml));
-    _E(dom == NULL, create_error(e_DefinitionError, "virDomainDefineXML", "", conn));
-
-    return domain_new(dom, c);
-}
-
-#if HAVE_VIRCONNECTDOMAINXMLFROMNATIVE
-/*
- * call-seq:
- *   conn.domain_xml_from_native -> string
- *
- * Call +virConnectDomainXMLFromNative+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainXMLFromNative]
- */
-static VALUE libvirt_conn_domain_xml_from_native(int argc, VALUE *argv, VALUE s) {
-    VALUE nativeFormat, xml, flags;
-    char *ret;
-    VALUE result;
-
-    rb_scan_args(argc, argv, "21", &nativeFormat, &xml, &flags);
-
-    if (NIL_P(flags))
-        flags = INT2FIX(0);
-
-    ret = virConnectDomainXMLFromNative(conn(s), StringValueCStr(nativeFormat),
-                                        StringValueCStr(xml), NUM2UINT(flags));
-    _E(ret == NULL,
-       create_error(e_Error, "virConnectDomainXMLFromNative", "", conn(s)));
-
-    result = rb_str_new2(ret);
-
-    free(ret);
-
-    return result;
-}
-#endif
-
-#if HAVE_VIRCONNECTDOMAINXMLTONATIVE
-/*
- * call-seq:
- *   conn.domain_xml_to_native -> string
- *
- * Call +virConnectDomainXMLToNative+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainXMLToNative]
- */
-static VALUE libvirt_conn_domain_xml_to_native(int argc, VALUE *argv, VALUE s) {
-    VALUE nativeFormat, xml, flags;
-    char *ret;
-    VALUE result;
-
-    rb_scan_args(argc, argv, "21", &nativeFormat, &xml, &flags);
-
-    if (NIL_P(flags))
-        flags = INT2FIX(0);
-
-    ret = virConnectDomainXMLToNative(conn(s), StringValueCStr(nativeFormat),
-                                      StringValueCStr(xml), NUM2UINT(flags));
-    _E(ret == NULL,
-       create_error(e_Error, "virConnectDomainXMLToNative", "", conn(s)));
-
-    result = rb_str_new2(ret);
-
-    free(ret);
-
-    return result;
-}
-#endif
-
-/*
- * call-seq:
- *   dom.migrate -> Libvirt::Domain
+ *   dom.migrate(dconn, flags=0, dname=nil, uri=nil, bandwidth=0) -> Libvirt::Domain
  *
  * Call +virDomainMigrate+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainMigrate]
+ * to migrate a domain from the host on this connection to the connection
+ * referenced in dconn.
  */
 static VALUE libvirt_dom_migrate(int argc, VALUE *argv, VALUE s) {
     VALUE dconn, flags, dname_val, uri_val, bandwidth;
@@ -286,8 +83,7 @@ static VALUE libvirt_dom_migrate(int argc, VALUE *argv, VALUE s) {
                             get_string_or_nil(dname_val),
                             get_string_or_nil(uri_val), NUM2ULONG(bandwidth));
 
-    _E(ddom == NULL,
-       create_error(e_Error, "virDomainMigrate", "", conn(s)));
+    _E(ddom == NULL, create_error(e_Error, "virDomainMigrate", conn(s)));
 
     return domain_new(ddom, dconn);
 }
@@ -295,13 +91,14 @@ static VALUE libvirt_dom_migrate(int argc, VALUE *argv, VALUE s) {
 #if HAVE_VIRDOMAINMIGRATETOURI
 /*
  * call-seq:
- *   dom.migrate_to_uri -> nil
+ *   dom.migrate_to_uri(duri, flags=0, dname=nil, bandwidth=0) -> nil
  *
  * Call +virDomainMigrateToURI+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainMigrateToURI]
+ * to migrate a domain from the host on this connection to the host whose
+ * libvirt URI is duri.
  */
 static VALUE libvirt_dom_migrate_to_uri(int argc, VALUE *argv, VALUE s) {
     VALUE flags, dname_val, bandwidth, duri_val;
-    int ret;
 
     rb_scan_args(argc, argv, "13", &duri_val, &flags, &dname_val, &bandwidth);
 
@@ -310,40 +107,31 @@ static VALUE libvirt_dom_migrate_to_uri(int argc, VALUE *argv, VALUE s) {
     if (NIL_P(flags))
         flags = INT2FIX(0);
 
-    ret = virDomainMigrateToURI(domain_get(s), StringValueCStr(duri_val),
-                                NUM2ULONG(flags), get_string_or_nil(dname_val),
-                                NUM2ULONG(bandwidth));
-
-    _E(ret < 0,
-       create_error(e_Error, "virDomainMigrateToURI", "", conn(s)));
-
-    return Qnil;
+    gen_call_void(virDomainMigrateToURI, conn(s), domain_get(s),
+                  StringValueCStr(duri_val), NUM2ULONG(flags),
+                  get_string_or_nil(dname_val), NUM2ULONG(bandwidth));
 }
 #endif
 
 #if HAVE_VIRDOMAINMIGRATESETMAXDOWNTIME
 /*
  * call-seq:
- *   dom.migrate_set_max_downtime -> nil
+ *   dom.migrate_set_max_downtime(downtime, flags=0) -> nil
  *
  * Call +virDomainMigrateSetMaxDowntime+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainMigrateSetMaxDowntime]
+ * to set the maximum downtime desired for live migration.
  */
-static VALUE libvirt_dom_migrate_set_max_downtime(int argc, VALUE *argv, VALUE s) {
+static VALUE libvirt_dom_migrate_set_max_downtime(int argc, VALUE *argv,
+                                                  VALUE s) {
     VALUE downtime, flags;
-    int ret;
 
     rb_scan_args(argc, argv, "11", &downtime, &flags);
 
     if (NIL_P(flags))
         flags = INT2FIX(0);
 
-    ret = virDomainMigrateSetMaxDowntime(domain_get(s), NUM2ULL(downtime),
-                                         NUM2UINT(flags));
-
-    _E(ret < 0,
-       create_error(e_Error, "virDomainMigrateSetMaxDowntime", "", conn(s)));
-
-    return Qnil;
+    gen_call_void(virDomainMigrateSetMaxDowntime, conn(s), domain_get(s),
+                  NUM2ULL(downtime), NUM2UINT(flags));
 }
 #endif
 
@@ -352,6 +140,9 @@ static VALUE libvirt_dom_migrate_set_max_downtime(int argc, VALUE *argv, VALUE s
  *   dom.shutdown -> nil
  *
  * Call +virDomainShutdown+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainShutdown]
+ * to do a soft shutdown of the domain.  The mechanism for doing the shutdown
+ * is hypervisor specific, and may require software running inside the domain
+ * to succeed.
  */
 static VALUE libvirt_dom_shutdown(VALUE s) {
     gen_call_void(virDomainShutdown, conn(s), domain_get(s));
@@ -359,9 +150,10 @@ static VALUE libvirt_dom_shutdown(VALUE s) {
 
 /*
  * call-seq:
- *   dom.reboot -> nil
+ *   dom.reboot(flags=0) -> nil
  *
  * Call +virDomainReboot+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainReboot]
+ * to do a reboot of the domain.
  */
 static VALUE libvirt_dom_reboot(int argc, VALUE *argv, VALUE s) {
     VALUE flags;
@@ -379,6 +171,7 @@ static VALUE libvirt_dom_reboot(int argc, VALUE *argv, VALUE s) {
  *   dom.destroy -> nil
  *
  * Call +virDomainDestroy+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainDestroy]
+ * to do a hard power-off of the domain.
  */
 static VALUE libvirt_dom_destroy(VALUE s) {
     gen_call_void(virDomainDestroy, conn(s), domain_get(s));
@@ -389,6 +182,8 @@ static VALUE libvirt_dom_destroy(VALUE s) {
  *   dom.suspend -> nil
  *
  * Call +virDomainSuspend+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSuspend]
+ * to stop the domain from executing.  The domain will still continue to
+ * consume memory, but will not take any CPU time.
  */
 static VALUE libvirt_dom_suspend(VALUE s) {
     gen_call_void(virDomainSuspend, conn(s), domain_get(s));
@@ -399,6 +194,8 @@ static VALUE libvirt_dom_suspend(VALUE s) {
  *   dom.resume -> nil
  *
  * Call +virDomainResume+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainResume]
+ * to resume a suspended domain.  After this call the domain will start
+ * consuming CPU resources again.
  */
 static VALUE libvirt_dom_resume(VALUE s) {
     gen_call_void(virDomainResume, conn(s), domain_get(s));
@@ -406,9 +203,11 @@ static VALUE libvirt_dom_resume(VALUE s) {
 
 /*
  * call-seq:
- *   dom.save -> nil
+ *   dom.save(filename) -> nil
  *
  * Call +virDomainSave+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSave]
+ * to save the domain state to filename.  After this call, the domain will no
+ * longer be consuming any resources.
  */
 static VALUE libvirt_dom_save(VALUE s, VALUE to) {
     gen_call_void(virDomainSave, conn(s), domain_get(s), StringValueCStr(to));
@@ -417,9 +216,11 @@ static VALUE libvirt_dom_save(VALUE s, VALUE to) {
 #if HAVE_VIRDOMAINMANAGEDSAVE
 /*
  * call-seq:
- *   dom.managed_save -> nil
+ *   dom.managed_save(flags=0) -> nil
  *
  * Call +virDomainManagedSave+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainManagedSave]
+ * to do a managed save of the domain.  The domain will be saved to a place
+ * of libvirt's choosing.
  */
 static VALUE libvirt_dom_managed_save(int argc, VALUE *argv, VALUE s) {
     VALUE flags;
@@ -435,9 +236,10 @@ static VALUE libvirt_dom_managed_save(int argc, VALUE *argv, VALUE s) {
 
 /*
  * call-seq:
- *   dom.has_managed_save -> [true|false]
+ *   dom.has_managed_save?(flags=0) -> [True|False]
  *
  * Call +virDomainHasManagedSaveImage+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainHasManagedSaveImage]
+ * to determine if a particular domain has a managed save image.
  */
 static VALUE libvirt_dom_has_managed_save(int argc, VALUE *argv, VALUE s) {
     VALUE flags;
@@ -453,9 +255,10 @@ static VALUE libvirt_dom_has_managed_save(int argc, VALUE *argv, VALUE s) {
 
 /*
  * call-seq:
- *   dom.managed_save_remove -> nil
+ *   dom.managed_save_remove(flags=0) -> nil
  *
  * Call +virDomainManagedSaveRemove+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainManagedSaveRemove]
+ * to remove the managed save image for a domain.
  */
 static VALUE libvirt_dom_managed_save_remove(int argc, VALUE *argv, VALUE s) {
     VALUE flags;
@@ -472,9 +275,10 @@ static VALUE libvirt_dom_managed_save_remove(int argc, VALUE *argv, VALUE s) {
 
 /*
  * call-seq:
- *   dom.core_dump -> nil
+ *   dom.core_dump(filename, flags=0) -> nil
  *
  * Call +virDomainCoreDump+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCoreDump]
+ * to do a full memory dump of the domain to filename.
  */
 static VALUE libvirt_dom_core_dump(int argc, VALUE *argv, VALUE s) {
     VALUE to, flags;
@@ -490,9 +294,22 @@ static VALUE libvirt_dom_core_dump(int argc, VALUE *argv, VALUE s) {
 
 /*
  * call-seq:
- *   dom.restore -> nil
+ *   dom.restore(filename) -> nil
  *
  * Call +virDomainRestore+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainRestore]
+ * to restore the domain from the filename.
+ */
+static VALUE libvirt_dom_restore(VALUE s, VALUE from) {
+    gen_call_void(virDomainRestore, conn(s), connect_get(s),
+                  StringValueCStr(from));
+}
+
+/*
+ * call-seq:
+ *   Libvirt::Domain::restore(conn, filename) -> nil
+ *
+ * Call +virDomainRestore+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainRestore]
+ * to restore the domain from the filename.
  */
 static VALUE libvirt_dom_s_restore(VALUE klass, VALUE c, VALUE from) {
     gen_call_void(virDomainRestore, conn(c), connect_get(c),
@@ -501,9 +318,10 @@ static VALUE libvirt_dom_s_restore(VALUE klass, VALUE c, VALUE from) {
 
 /*
  * call-seq:
- *   domain.info -> Libvirt::Domain::Info
+ *   dom.info -> Libvirt::Domain::Info
  *
  * Call +virDomainGetInfo+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetInfo]
+ * to retrieve domain information.
  */
 static VALUE libvirt_dom_info(VALUE s) {
     virDomainPtr dom = domain_get(s);
@@ -512,7 +330,7 @@ static VALUE libvirt_dom_info(VALUE s) {
     VALUE result;
 
     r = virDomainGetInfo(dom, &info);
-    _E(r < 0, create_error(e_RetrieveError, "virDomainGetInfo", "", conn(s)));
+    _E(r < 0, create_error(e_RetrieveError, "virDomainGetInfo", conn(s)));
 
     result = rb_class_new_instance(0, NULL, c_domain_info);
     rb_iv_set(result, "@state", CHR2FIX(info.state));
@@ -520,14 +338,17 @@ static VALUE libvirt_dom_info(VALUE s) {
     rb_iv_set(result, "@memory", ULONG2NUM(info.memory));
     rb_iv_set(result, "@nr_virt_cpu", INT2FIX((int) info.nrVirtCpu));
     rb_iv_set(result, "@cpu_time", ULL2NUM(info.cpuTime));
+
     return result;
 }
 
+#if HAVE_VIRDOMAINGETSECURITYLABEL
 /*
  * call-seq:
- *   domain.security_label -> Libvirt::Domain::SecurityLabel
+ *   dom.security_label -> Libvirt::Domain::SecurityLabel
  *
  * Call +virDomainGetSecurityLabel+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetSecurityLabel]
+ * to retrieve the security label applied to this domain.
  */
 static VALUE libvirt_dom_security_label(VALUE s) {
     virDomainPtr dom = domain_get(s);
@@ -536,7 +357,8 @@ static VALUE libvirt_dom_security_label(VALUE s) {
     VALUE result;
 
     r = virDomainGetSecurityLabel(dom, &seclabel);
-    _E(r < 0, create_error(e_RetrieveError, "virDomainGetSecurityLabel", "", conn(s)));
+    _E(r < 0, create_error(e_RetrieveError, "virDomainGetSecurityLabel",
+                           conn(s)));
 
     result = rb_class_new_instance(0, NULL, c_domain_security_label);
     rb_iv_set(result, "@label", rb_str_new2(seclabel.label));
@@ -544,12 +366,14 @@ static VALUE libvirt_dom_security_label(VALUE s) {
 
     return result;
 }
+#endif
 
 /*
  * call-seq:
- *   domain.block_stats -> Libvirt::Domain::BlockStats
+ *   dom.block_stats(path) -> Libvirt::Domain::BlockStats
  *
  * Call +virDomainBlockStats+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainBlockStats]
+ * to retrieve statistics about domain block device path.
  */
 static VALUE libvirt_dom_block_stats(VALUE s, VALUE path) {
     virDomainPtr dom = domain_get(s);
@@ -558,7 +382,7 @@ static VALUE libvirt_dom_block_stats(VALUE s, VALUE path) {
     VALUE result;
 
     r = virDomainBlockStats(dom, StringValueCStr(path), &stats, sizeof(stats));
-    _E(r < 0, create_error(e_RetrieveError, "virDomainBlockStats", "", conn(s)));
+    _E(r < 0, create_error(e_RetrieveError, "virDomainBlockStats", conn(s)));
 
     result = rb_class_new_instance(0, NULL, c_domain_block_stats);
     rb_iv_set(result, "@rd_req", LL2NUM(stats.rd_req));
@@ -573,9 +397,10 @@ static VALUE libvirt_dom_block_stats(VALUE s, VALUE path) {
 #if HAVE_TYPE_VIRDOMAINMEMORYSTATPTR
 /*
  * call-seq:
- *   domain.memory_stats -> Libvirt::Domain::MemoryStats
+ *   dom.memory_stats(flags=0) -> [ Libvirt::Domain::MemoryStats ]
  *
  * Call +virDomainMemoryStats+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainMemoryStats]
+ * to retrieve statistics about the amount of memory consumed by a domain.
  */
 static VALUE libvirt_dom_memory_stats(int argc, VALUE *argv, VALUE s) {
     virDomainPtr dom = domain_get(s);
@@ -592,8 +417,18 @@ static VALUE libvirt_dom_memory_stats(int argc, VALUE *argv, VALUE s) {
         flags = INT2FIX(0);
 
     r = virDomainMemoryStats(dom, stats, 6, NUM2UINT(flags));
-    _E(r < 0, create_error(e_RetrieveError, "virDomainMemoryStats", "", conn(s)));
+    _E(r < 0, create_error(e_RetrieveError, "virDomainMemoryStats", conn(s)));
 
+    /* FIXME: the right rubyish way to have done this would have been to
+     * create a hash with the values, something like:
+     *
+     * { 'SWAP_IN' => 0, 'SWAP_OUT' => 98, 'MAJOR_FAULT' => 45,
+     *   'MINOR_FAULT' => 55, 'UNUSED' => 455, 'AVAILABLE' => 98 }
+     *
+     * Unfortunately this has already been released with the array version
+     * so we have to maintain compatibility with that.  We should probably add
+     * a new memory_stats-like call that properly creates the hash.
+     */
     result = rb_ary_new2(r);
     for (i=0; i<r; i++) {
         tmp = rb_class_new_instance(0, NULL, c_domain_memory_stats);
@@ -610,9 +445,10 @@ static VALUE libvirt_dom_memory_stats(int argc, VALUE *argv, VALUE s) {
 #if HAVE_TYPE_VIRDOMAINBLOCKINFOPTR
 /*
  * call-seq:
- *   domain.block_info -> Libvirt::Domain::BlockInfo
+ *   dom.blockinfo(path, flags=0) -> Libvirt::Domain::BlockInfo
  *
  * Call +virDomainGetBlockInfo+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetBlockInfo]
+ * to retrieve information about the backing file path for the domain.
  */
 static VALUE libvirt_dom_block_info(int argc, VALUE *argv, VALUE s) {
     virDomainPtr dom = domain_get(s);
@@ -627,8 +463,9 @@ static VALUE libvirt_dom_block_info(int argc, VALUE *argv, VALUE s) {
     if (NIL_P(flags))
         flags = INT2FIX(0);
 
-    r = virDomainGetBlockInfo(dom, StringValueCStr(path), &info, NUM2UINT(flags));
-    _E(r < 0, create_error(e_RetrieveError, "virDomainGetBlockInfo", "", conn(s)));
+    r = virDomainGetBlockInfo(dom, StringValueCStr(path), &info,
+                              NUM2UINT(flags));
+    _E(r < 0, create_error(e_RetrieveError, "virDomainGetBlockInfo", conn(s)));
 
     result = rb_class_new_instance(0, NULL, c_domain_block_info);
     rb_iv_set(result, "@capacity", ULL2NUM(info.capacity));
@@ -639,77 +476,264 @@ static VALUE libvirt_dom_block_info(int argc, VALUE *argv, VALUE s) {
 }
 #endif
 
+#if HAVE_VIRDOMAINBLOCKPEEK
 /*
  * call-seq:
- *   domain.block_peek -> string
+ *   dom.block_peek(path, offset, size, flags=0) -> string
  *
  * Call +virDomainBlockPeek+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainBlockPeek]
+ * to read size number of bytes, starting at offset offset from domain backing
+ * file path.  Due to limitations of the libvirt remote protocol, the user
+ * should never request more than 64k bytes.
  */
 static VALUE libvirt_dom_block_peek(int argc, VALUE *argv, VALUE s) {
     virDomainPtr dom = domain_get(s);
-    VALUE path, offset, size, flags;
+    VALUE path_val, offset_val, size_val, flags_val;
     char *buffer;
     int r;
     VALUE ret;
+    char *path;
+    unsigned int size, flags;
+    unsigned long long offset;
+    struct rb_str_new_arg args;
+    int exception = 0;
 
-    rb_scan_args(argc, argv, "31", &path, &offset, &size, &flags);
+    rb_scan_args(argc, argv, "31", &path_val, &offset_val, &size_val,
+                 &flags_val);
 
-    if (NIL_P(flags))
-        flags = INT2FIX(0);
+    if (NIL_P(flags_val))
+        flags_val = INT2FIX(0);
 
-    buffer = ALLOC_N(char, size);
+    path = StringValueCStr(path_val);
+    offset = NUM2ULL(offset_val);
+    size = NUM2UINT(size_val);
+    flags = NUM2UINT(flags_val);
 
-    r = virDomainBlockPeek(dom, StringValueCStr(path),
-                           NUM2ULL(offset), NUM2UINT(size), buffer,
-                           NUM2UINT(flags));
+    buffer = ALLOC_N(char, size);
 
-    _E(r < 0, create_error(e_RetrieveError, "virDomainBlockPeek", "", conn(s)));
+    r = virDomainBlockPeek(dom, path, offset, size, buffer, flags);
 
-    ret = rb_str_new((char *)buffer, size);
+    if (r < 0) {
+        xfree(buffer);
+        rb_exc_raise(create_error(e_RetrieveError, "virDomainBlockPeek",
+                                  conn(s)));
+    }
 
-    free(buffer);
+    args.val = buffer;
+    args.size = size;
+    ret = rb_protect(rb_str_new_wrap, (VALUE)&args, &exception);
+    xfree(buffer);
+    if (exception)
+        rb_jump_tag(exception);
 
     return ret;
 }
+#endif
 
+#if HAVE_VIRDOMAINMEMORYPEEK
 /*
  * call-seq:
- *   domain.memory_peek -> string
+ *   dom.memory_peek(start, size, flags=Libvirt::Domain::MEMORY_VIRTUAL) -> string
  *
  * Call +virDomainMemoryPeek+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainMemoryPeek]
+ * to read size number of bytes from offset start from the domain memory.
+ * Due to limitations of the libvirt remote protocol, the user
+ * should never request more than 64k bytes.
  */
 static VALUE libvirt_dom_memory_peek(int argc, VALUE *argv, VALUE s) {
     virDomainPtr dom = domain_get(s);
-    VALUE start, size, flags;
+    VALUE start_val, size_val, flags_val;
     char *buffer;
     int r;
     VALUE ret;
+    unsigned int size, flags;
+    unsigned long long start;
+    struct rb_str_new_arg args;
+    int exception = 0;
 
-    rb_scan_args(argc, argv, "21", &start, &size, &flags);
+    rb_scan_args(argc, argv, "21", &start_val, &size_val, &flags_val);
 
-    if (NIL_P(flags))
-        flags = INT2FIX(0);
+    if (NIL_P(flags_val))
+        flags_val = INT2FIX(VIR_MEMORY_VIRTUAL);
 
-    buffer = ALLOC_N(char, size);
+    start = NUM2UINT(start_val);
+    size = NUM2UINT(size_val);
+    flags = NUM2UINT(flags_val);
 
-    r = virDomainMemoryPeek(dom, NUM2ULL(start), NUM2UINT(size), buffer,
-                           NUM2UINT(flags));
+    buffer = ALLOC_N(char, size);
 
-    _E(r < 0, create_error(e_RetrieveError, "virDomainMemoryPeek", "", conn(s)));
+    r = virDomainMemoryPeek(dom, start, size, buffer, flags);
 
-    ret = rb_str_new((char *)buffer, size);
+    if (r < 0) {
+        xfree(buffer);
+        rb_exc_raise(create_error(e_RetrieveError, "virDomainMemoryPeek",
+                                  conn(s)));
+    }
 
-    free(buffer);
+    args.val = buffer;
+    args.size = size;
+    ret = rb_protect(rb_str_new_wrap, (VALUE)&args, &exception);
+    xfree(buffer);
+    if (exception)
+        rb_jump_tag(exception);
 
     return ret;
 }
+#endif
+
+/* call-seq:
+ *   dom.get_vcpus -> [ Libvirt::Domain::VCPUInfo ]
+ *
+ * Call +virDomainGetVcpus+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetVcpus]
+ * to retrieve detailed information about the state of a domain's virtual CPUs.
+ */
+static VALUE libvirt_dom_get_vcpus(VALUE s) {
+    virDomainPtr dom = domain_get(s);
+    virNodeInfo nodeinfo;
+    virDomainInfo dominfo;
+    virVcpuInfoPtr cpuinfo;
+    unsigned char *cpumap;
+    int cpumaplen;
+    int r, i, j;
+    VALUE vcpuinfo;
+    VALUE p2vcpumap;
+    VALUE result;
+    int exception = 0;
+    struct rb_ary_push_arg args;
+    struct rb_iv_set_arg iv_args;
+    struct rb_class_new_instance_arg klass_args;
+
+    r = virNodeGetInfo(conn(s), &nodeinfo);
+    _E(r < 0, create_error(e_RetrieveError, "virNodeGetInfo", conn(s)));
+
+    r = virDomainGetInfo(dom, &dominfo);
+    _E(r < 0, create_error(e_RetrieveError, "virDomainGetInfo", conn(s)));
+
+    cpuinfo = ALLOC_N(virVcpuInfo, dominfo.nrVirtCpu);
+
+    cpumaplen = VIR_CPU_MAPLEN(VIR_NODEINFO_MAXCPUS(nodeinfo));
+
+    /* we use malloc instead of ruby_xmalloc here to avoid a memory leak
+     * if ruby_xmalloc raises an exception
+     */
+    cpumap = malloc(dominfo.nrVirtCpu * cpumaplen);
+    if (cpumap == NULL) {
+        xfree(cpuinfo);
+        rb_memerror();
+    }
+
+    r = virDomainGetVcpus(dom, cpuinfo, dominfo.nrVirtCpu, cpumap, cpumaplen);
+    if (r < 0) {
+        xfree(cpuinfo);
+        free(cpumap);
+        rb_exc_raise(create_error(e_RetrieveError, "virDomainGetVcpus",
+                                  conn(s)));
+    }
+
+    result = rb_protect(rb_ary_new_wrap, (VALUE)NULL, &exception);
+    if (exception) {
+        xfree(cpuinfo);
+        free(cpumap);
+        rb_jump_tag(exception);
+    }
+
+    for (i = 0; i < dominfo.nrVirtCpu; i++) {
+        klass_args.argc = 0;
+        klass_args.argv = NULL;
+        klass_args.klass = c_domain_vcpuinfo;
+        vcpuinfo = rb_protect(rb_class_new_instance_wrap, (VALUE)&klass_args,
+                              &exception);
+        if (exception) {
+            xfree(cpuinfo);
+            free(cpumap);
+            rb_jump_tag(exception);
+        }
+
+        iv_args.klass = vcpuinfo;
+        iv_args.member = "@number";
+        iv_args.value = UINT2NUM(cpuinfo[i].number);
+        rb_protect(rb_iv_set_wrap, (VALUE)&iv_args, &exception);
+        if (exception) {
+            xfree(cpuinfo);
+            free(cpumap);
+            rb_jump_tag(exception);
+        }
+        iv_args.member = "@state";
+        iv_args.value = INT2NUM(cpuinfo[i].state);
+        rb_protect(rb_iv_set_wrap, (VALUE)&iv_args, &exception);
+        if (exception) {
+            xfree(cpuinfo);
+            free(cpumap);
+            rb_jump_tag(exception);
+        }
+        iv_args.member = "@cpu_time";
+        iv_args.value = ULL2NUM(cpuinfo[i].cpuTime);
+        rb_protect(rb_iv_set_wrap, (VALUE)&iv_args, &exception);
+        if (exception) {
+            xfree(cpuinfo);
+            free(cpumap);
+            rb_jump_tag(exception);
+        }
+        iv_args.member = "@cpu";
+        iv_args.value = INT2NUM(cpuinfo[i].cpu);
+        rb_protect(rb_iv_set_wrap, (VALUE)&iv_args, &exception);
+        if (exception) {
+            xfree(cpuinfo);
+            free(cpumap);
+            rb_jump_tag(exception);
+        }
+
+        p2vcpumap = rb_protect(rb_ary_new_wrap, (VALUE)NULL, &exception);
+        if (exception) {
+            xfree(cpuinfo);
+            free(cpumap);
+            rb_jump_tag(exception);
+        }
+
+        for (j = 0; j < VIR_NODEINFO_MAXCPUS(nodeinfo); j++) {
+            args.arr = p2vcpumap;
+            args.value = (VIR_CPU_USABLE(cpumap, cpumaplen, i, j)) ? Qtrue : Qfalse;
+            rb_protect(rb_ary_push_wrap, (VALUE)&args, &exception);
+            if (exception) {
+                xfree(cpuinfo);
+                free(cpumap);
+                rb_jump_tag(exception);
+            }
+        }
+
+        iv_args.klass = vcpuinfo;
+        iv_args.member = "@cpumap";
+        iv_args.value = p2vcpumap;
+        rb_protect(rb_iv_set_wrap, (VALUE)&iv_args, &exception);
+        if (exception) {
+            xfree(cpuinfo);
+            free(cpumap);
+            rb_jump_tag(exception);
+        }
+
+        args.arr = result;
+        args.value = vcpuinfo;
+        rb_protect(rb_ary_push_wrap, (VALUE)&args, &exception);
+        if (exception) {
+            xfree(cpuinfo);
+            free(cpumap);
+            rb_jump_tag(exception);
+        }
+    }
+
+    free(cpumap);
+    xfree(cpuinfo);
+
+    return result;
+}
 
 #if HAVE_VIRDOMAINISACTIVE
 /*
  * call-seq:
- *   domain.active? -> [true|false]
+ *   dom.active? -> [true|false]
  *
  * Call +virDomainIsActive+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainIsActive]
+ * to determine if this domain is currently active.
  */
 static VALUE libvirt_dom_active_p(VALUE d) {
     gen_call_truefalse(virDomainIsActive, conn(d), domain_get(d));
@@ -719,9 +743,10 @@ static VALUE libvirt_dom_active_p(VALUE d) {
 #if HAVE_VIRDOMAINISPERSISTENT
 /*
  * call-seq:
- *   domain.persistent? -> [true|false]
+ *   dom.persistent? -> [true|false]
  *
  * Call +virDomainIsPersistent+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainIsPersistent]
+ * to determine if this is a persistent domain.
  */
 static VALUE libvirt_dom_persistent_p(VALUE d) {
     gen_call_truefalse(virDomainIsPersistent, conn(d), domain_get(d));
@@ -730,9 +755,10 @@ static VALUE libvirt_dom_persistent_p(VALUE d) {
 
 /*
  * call-seq:
- *   domain.ifinfo -> Libvirt::Domain::IfInfo
+ *   dom.ifinfo(if) -> Libvirt::Domain::IfInfo
  *
  * Call +virDomainInterfaceStats+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainInterfaceStats]
+ * to retrieve statistics about domain interface if.
  */
 static VALUE libvirt_dom_if_stats(VALUE s, VALUE sif) {
     virDomainPtr dom = domain_get(s);
@@ -744,7 +770,7 @@ static VALUE libvirt_dom_if_stats(VALUE s, VALUE sif) {
     if (ifname) {
         r = virDomainInterfaceStats(dom, ifname, &ifinfo,
                                     sizeof(virDomainInterfaceStatsStruct));
-        _E(r < 0, create_error(e_RetrieveError, "virDomainInterfaceStats", "",
+        _E(r < 0, create_error(e_RetrieveError, "virDomainInterfaceStats",
                                conn(s)));
 
         result = rb_class_new_instance(0, NULL, c_domain_ifinfo);
@@ -765,6 +791,7 @@ static VALUE libvirt_dom_if_stats(VALUE s, VALUE sif) {
  *   dom.name -> string
  *
  * Call +virDomainGetName+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetName]
+ * to retrieve the name of this domain.
  */
 static VALUE libvirt_dom_name(VALUE s) {
     gen_call_string(virDomainGetName, conn(s), 0, domain_get(s));
@@ -775,6 +802,8 @@ static VALUE libvirt_dom_name(VALUE s) {
  *   dom.id -> fixnum
  *
  * Call +virDomainGetID+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetID]
+ * to retrieve the ID of this domain.  If the domain isn't running, this will
+ * be -1.
  */
 static VALUE libvirt_dom_id(VALUE s) {
     virDomainPtr dom = domain_get(s);
@@ -782,7 +811,8 @@ static VALUE libvirt_dom_id(VALUE s) {
     int out;
 
     id = virDomainGetID(dom);
-    _E(id < 0, create_error(e_RetrieveError, "virDomainGetID", "", conn(s)));
+    _E(id == (unsigned int)-1, create_error(e_RetrieveError, "virDomainGetID",
+                                            conn(s)));
 
     /* we need to cast the unsigned int id to a signed int out to handle the
      * -1 case
@@ -797,6 +827,7 @@ static VALUE libvirt_dom_id(VALUE s) {
  *   dom.uuid -> string
  *
  * Call +virDomainGetUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetUUIDString]
+ * to retrieve the UUID of this domain.
  */
 static VALUE libvirt_dom_uuid(VALUE s) {
     virDomainPtr dom = domain_get(s);
@@ -804,7 +835,7 @@ static VALUE libvirt_dom_uuid(VALUE s) {
     int r;
 
     r = virDomainGetUUIDString(dom, uuid);
-    _E(r < 0, create_error(e_RetrieveError, "virDomainGetUUIDString", "", conn(s)));
+    _E(r < 0, create_error(e_RetrieveError, "virDomainGetUUIDString", conn(s)));
 
     return rb_str_new2((char *) uuid);
 }
@@ -814,6 +845,8 @@ static VALUE libvirt_dom_uuid(VALUE s) {
  *   dom.os_type -> string
  *
  * Call +virDomainGetOSType+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetOSType]
+ * to retrieve the os_type of this domain.  In libvirt terms, os_type determines
+ * whether this domain is fully virtualized, paravirtualized, or a container.
  */
 static VALUE libvirt_dom_os_type(VALUE s) {
     gen_call_string(virDomainGetOSType, conn(s), 1, domain_get(s));
@@ -824,45 +857,55 @@ static VALUE libvirt_dom_os_type(VALUE s) {
  *   dom.max_memory -> fixnum
  *
  * Call +virDomainGetMaxMemory+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetMaxMemory]
+ * to retrieve the maximum amount of memory this domain is allowed to access.
+ * Note that the current amount of memory this domain is allowed to access may
+ * be different (see dom.memory_set).
  */
 static VALUE libvirt_dom_max_memory(VALUE s) {
     virDomainPtr dom = domain_get(s);
     unsigned long max_memory;
 
     max_memory = virDomainGetMaxMemory(dom);
-    _E(max_memory == 0, create_error(e_RetrieveError, "virDomainGetMaxMemory", "", conn(s)));
+    _E(max_memory == 0, create_error(e_RetrieveError, "virDomainGetMaxMemory",
+                                     conn(s)));
 
     return ULONG2NUM(max_memory);
 }
 
 /*
  * call-seq:
- *   dom.max_memory_set -> nil
+ *   dom.max_memory = Fixnum
  *
  * Call +virDomainSetMaxMemory+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSetMaxMemory]
+ * to set the maximum amount of memory (in kilobytes) this domain should be
+ * allowed to access.
  */
 static VALUE libvirt_dom_max_memory_set(VALUE s, VALUE max_memory) {
     virDomainPtr dom = domain_get(s);
     int r;
 
     r = virDomainSetMaxMemory(dom, NUM2ULONG(max_memory));
-    _E(r < 0, create_error(e_DefinitionError, "virDomainSetMaxMemory", "", conn(s)));
+    _E(r < 0, create_error(e_DefinitionError, "virDomainSetMaxMemory",
+                           conn(s)));
 
     return ULONG2NUM(max_memory);
 }
 
 /*
  * call-seq:
- *   dom.memory_set -> void
+ *   dom.memory = Fixnum
  *
  * Call +virDomainSetMemory+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSetMemory]
+ * to set the amount of memory (in kilobytes) this domain should currently
+ * have.  Note this will only succeed if both the hypervisor and the domain on
+ * this connection support ballooning.
  */
 static VALUE libvirt_dom_memory_set(VALUE s, VALUE memory) {
     virDomainPtr dom = domain_get(s);
     int r;
 
     r = virDomainSetMemory(dom, NUM2ULONG(memory));
-    _E(r < 0, create_error(e_DefinitionError, "virDomainSetMemory", "", conn(s)));
+    _E(r < 0, create_error(e_DefinitionError, "virDomainSetMemory", conn(s)));
 
     return ULONG2NUM(memory);
 }
@@ -872,33 +915,74 @@ static VALUE libvirt_dom_memory_set(VALUE s, VALUE memory) {
  *   dom.max_vcpus -> fixnum
  *
  * Call +virDomainGetMaxVcpus+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetMaxVcpus]
+ * to retrieve the maximum number of virtual CPUs this domain can use.
  */
 static VALUE libvirt_dom_max_vcpus(VALUE s) {
-    virDomainPtr dom = domain_get(s);
-    int vcpus;
-
-    vcpus = virDomainGetMaxVcpus(dom);
-    _E(vcpus < 0, create_error(e_RetrieveError, "virDomainGetMaxVcpus", "", conn(s)));
-
-    return INT2NUM(vcpus);
+    gen_call_int(virDomainGetMaxVcpus, conn(s), domain_get(s));
 }
 
+#if HAVE_VIRDOMAINGETVCPUSFLAGS
+/* call-seq:
+ *   dom.num_vcpus(flags) -> fixnum
+ *
+ * Call +virDomainGetVcpusFlags+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetVcpusFlags]
+ * to retrieve the number of virtual CPUs assigned to this domain.
+ */
+static VALUE libvirt_dom_num_vcpus(VALUE d, VALUE flags) {
+    gen_call_int(virDomainGetVcpusFlags, conn(d), domain_get(d),
+                 NUM2UINT(flags));
+}
+#endif
 
 /*
  * call-seq:
- *   dom.vcpus_set -> nil
+ *   dom.vcpus = Fixnum
  *
  * Call +virDomainSetVcpus+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSetVcpus]
+ * to set the current number of virtual CPUs this domain should have.  Note
+ * that this will only work if both the hypervisor and domain on this
+ * connection support virtual CPU hotplug/hot-unplug.
  */
 static VALUE libvirt_dom_vcpus_set(VALUE s, VALUE nvcpus) {
     gen_call_void(virDomainSetVcpus, conn(s), domain_get(s), NUM2UINT(nvcpus));
 }
 
+#if HAVE_VIRDOMAINSETVCPUSFLAGS
 /*
  * call-seq:
- *   dom.pin_vcpu -> nil
+ *   dom.vcpus_flags = Fixnum,flags
+ *
+ * Call +virDomainSetVcpusFlags+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSetVcpusFlags]
+ * to set the current number of virtual CPUs this domain should have.  The
+ * flags parameter controls whether the change is made to the running domain
+ * the domain configuration, or both, and must not be 0.
+ */
+static VALUE libvirt_dom_vcpus_set_flags(VALUE s, VALUE vcpus) {
+    VALUE nvcpus;
+    VALUE flags;
+
+    Check_Type(vcpus, T_ARRAY);
+
+    if (RARRAY_LEN(vcpus) != 2)
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
+                 RARRAY_LEN(vcpus));
+
+    nvcpus = rb_ary_entry(vcpus, 0);
+    flags = rb_ary_entry(vcpus, 1);
+
+    gen_call_void(virDomainSetVcpusFlags, conn(s), domain_get(s),
+                  NUM2UINT(nvcpus), NUM2UINT(flags));
+}
+#endif
+
+/*
+ * call-seq:
+ *   dom.pin_vcpu(vcpu, cpulist) -> nil
  *
  * Call +virDomainPinVcpu+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainPinVcpu]
+ * to pin a particular virtual CPU to a range of physical processors.  The
+ * cpulist should be an array of Fixnums representing the physical processors
+ * this virtual CPU should be allowed to be scheduled on.
  */
 static VALUE libvirt_dom_pin_vcpu(VALUE s, VALUE vcpu, VALUE cpulist) {
     virDomainPtr dom = domain_get(s);
@@ -906,32 +990,37 @@ static VALUE libvirt_dom_pin_vcpu(VALUE s, VALUE vcpu, VALUE cpulist) {
     unsigned char *cpumap;
     virNodeInfo nodeinfo;
     virConnectPtr c = conn(s);
+    unsigned int vcpunum;
+
+    vcpunum = NUM2UINT(vcpu);
+    Check_Type(cpulist, T_ARRAY);
 
     r = virNodeGetInfo(c, &nodeinfo);
-    _E(r < 0, create_error(e_RetrieveError, "virNodeGetInfo", "", c));
+    _E(r < 0, create_error(e_RetrieveError, "virNodeGetInfo", c));
 
     maplen = VIR_CPU_MAPLEN(nodeinfo.cpus);
     cpumap = ALLOC_N(unsigned char, maplen);
     MEMZERO(cpumap, unsigned char, maplen);
 
-    len = RARRAY(cpulist)->len;
+    len = RARRAY_LEN(cpulist);
     for(i = 0; i < len; i++) {
         VALUE e = rb_ary_entry(cpulist, i);
         VIR_USE_CPU(cpumap, NUM2UINT(e));
     }
 
-    r = virDomainPinVcpu(dom, NUM2UINT(vcpu), cpumap, maplen);
-    free(cpumap);
-    _E(r < 0, create_error(e_RetrieveError, "virDomainPinVcpu", "", c));
+    r = virDomainPinVcpu(dom, vcpunum, cpumap, maplen);
+    xfree(cpumap);
+    _E(r < 0, create_error(e_RetrieveError, "virDomainPinVcpu", c));
 
     return Qnil;
 }
 
 /*
  * call-seq:
- *   dom.xml_desc -> string
+ *   dom.xml_desc(flags=0) -> string
  *
  * Call +virDomainGetXMLDesc+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetXMLDesc]
+ * to retrieve the XML describing this domain.
  */
 static VALUE libvirt_dom_xml_desc(int argc, VALUE *argv, VALUE s) {
     VALUE flags;
@@ -950,6 +1039,8 @@ static VALUE libvirt_dom_xml_desc(int argc, VALUE *argv, VALUE s) {
  *   dom.undefine -> nil
  *
  * Call +virDomainUndefine+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainUndefine]
+ * to undefine the domain.  After this call, the domain object is no longer
+ * valid.
  */
 static VALUE libvirt_dom_undefine(VALUE s) {
     gen_call_void(virDomainUndefine, conn(s), domain_get(s));
@@ -957,12 +1048,26 @@ static VALUE libvirt_dom_undefine(VALUE s) {
 
 /*
  * call-seq:
- *   dom.create -> nil
+ *   dom.create(flags=0) -> nil
  *
  * Call +virDomainCreate+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCreate]
+ * to start an already defined domain.
  */
-static VALUE libvirt_dom_create(VALUE s) {
+static VALUE libvirt_dom_create(int argc, VALUE *argv, VALUE s) {
+    VALUE flags;
+
+    rb_scan_args(argc, argv, "01", &flags);
+
+    if (NIL_P(flags))
+        flags = INT2FIX(0);
+
+#if HAVE_VIRDOMAINCREATEWITHFLAGS
+    gen_call_void(virDomainCreateWithFlags, conn(s), domain_get(s), NUM2UINT(flags));
+#else
+    if (NUM2UINT(flags) != 0)
+        rb_raise(e_NoSupportError, "Non-zero flags not supported");
     gen_call_void(virDomainCreate, conn(s), domain_get(s));
+#endif
 }
 
 /*
@@ -970,55 +1075,116 @@ static VALUE libvirt_dom_create(VALUE s) {
  *   dom.autostart -> [true|false]
  *
  * Call +virDomainGetAutostart+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetAutostart]
+ * to find out the state of the autostart flag for a domain.
  */
 static VALUE libvirt_dom_autostart(VALUE s){
     virDomainPtr dom = domain_get(s);
     int r, autostart;
 
     r = virDomainGetAutostart(dom, &autostart);
-    _E(r < 0, create_error(e_RetrieveError, "virDomainAutostart", "", conn(s)));
+    _E(r < 0, create_error(e_RetrieveError, "virDomainAutostart", conn(s)));
 
     return autostart ? Qtrue : Qfalse;
 }
 
 /*
  * call-seq:
- *   dom.autostart_set -> nil
+ *   dom.autostart = [true|false]
  *
  * Call +virDomainSetAutostart+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSetAutostart]
+ * to make this domain autostart when libvirtd starts up.
  */
 static VALUE libvirt_dom_autostart_set(VALUE s, VALUE autostart) {
+    if (autostart != Qtrue && autostart != Qfalse)
+		rb_raise(rb_eTypeError,
+                 "wrong argument type (expected TrueClass or FalseClass)");
+
     gen_call_void(virDomainSetAutostart, conn(s),
                   domain_get(s), RTEST(autostart) ? 1 : 0);
 }
 
 /*
  * call-seq:
- *   dom.attach_device -> nil
+ *   dom.attach_device(device_xml, flags=0) -> nil
  *
  * Call +virDomainAttachDevice+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainAttachDevice]
+ * to attach the device described by the device_xml to the domain.
  */
-static VALUE libvirt_dom_attach_device(VALUE s, VALUE xml) {
+static VALUE libvirt_dom_attach_device(int argc, VALUE *argv, VALUE s) {
+    VALUE xml;
+    VALUE flags;
+
+    rb_scan_args(argc, argv, "11", &xml, &flags);
+
+    if (NIL_P(flags))
+        flags = INT2FIX(0);
+
+#if HAVE_VIRDOMAINATTACHDEVICEFLAGS
+    gen_call_void(virDomainAttachDeviceFlags, conn(s), domain_get(s),
+                  StringValueCStr(xml), NUM2UINT(flags));
+#else
+    if (NUM2UINT(flags) != 0)
+        rb_raise(e_NoSupportError, "Non-zero flags not supported");
     gen_call_void(virDomainAttachDevice, conn(s), domain_get(s),
                   StringValueCStr(xml));
+#endif
 }
 
 /*
  * call-seq:
- *   dom.detach_device -> nil
+ *   dom.detach_device(device_xml, flags=0) -> nil
  *
  * Call +virDomainDetachDevice+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainDetachDevice]
+ * to detach the device described by the device_xml from the domain.
  */
-static VALUE libvirt_dom_detach_device(VALUE s, VALUE xml) {
+static VALUE libvirt_dom_detach_device(int argc, VALUE *argv, VALUE s) {
+    VALUE xml;
+    VALUE flags;
+
+    rb_scan_args(argc, argv, "11", &xml, &flags);
+
+    if (NIL_P(flags))
+        flags = INT2FIX(0);
+
+#if HAVE_VIRDOMAINDETACHDEVICEFLAGS
+    gen_call_void(virDomainDetachDeviceFlags, conn(s), domain_get(s),
+                  StringValueCStr(xml), NUM2UINT(flags));
+#else
+    if (NUM2UINT(flags) != 0)
+        rb_raise(e_NoSupportError, "Non-zero flags not supported");
     gen_call_void(virDomainDetachDevice, conn(s), domain_get(s),
                   StringValueCStr(xml));
+#endif
+}
+
+#if HAVE_VIRDOMAINUPDATEDEVICEFLAGS
+/*
+ * call-seq:
+ *   dom.update_device(device_xml, flags=0) -> nil
+ *
+ * Call +virDomainUpdateDeviceFlags+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainUpdateDeviceFlags]
+ * to update the device described by the device_xml.
+ */
+static VALUE libvirt_dom_update_device(int argc, VALUE *argv, VALUE s) {
+    VALUE xml;
+    VALUE flags;
+
+    rb_scan_args(argc, argv, "11", &xml, &flags);
+
+    if (NIL_P(flags))
+        flags = INT2FIX(0);
+
+    gen_call_void(virDomainUpdateDeviceFlags, conn(s), domain_get(s),
+                  StringValueCStr(xml), NUM2UINT(flags));
 }
+#endif
 
 /*
  * call-seq:
  *   dom.free -> nil
  *
  * Call +virDomainFree+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainFree]
+ * to free a domain object.
  */
 static VALUE libvirt_dom_free(VALUE s) {
     gen_call_free(Domain, s);
@@ -1042,9 +1208,10 @@ static virDomainSnapshotPtr domain_snapshot_get(VALUE s) {
 
 /*
  * call-seq:
- *   dom.snapshot_create_xml -> Libvirt::Domain::Snapshot
+ *   dom.snapshot_create_xml(snapshot_xml, flags=0) -> Libvirt::Domain::Snapshot
  *
  * Call +virDomainSnapshotCreateXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSnapshotCreateXML]
+ * to create a new snapshot based on snapshot_xml.
  */
 static VALUE libvirt_dom_snapshot_create_xml(int argc, VALUE *argv, VALUE d) {
     VALUE xmlDesc, flags;
@@ -1058,20 +1225,20 @@ static VALUE libvirt_dom_snapshot_create_xml(int argc, VALUE *argv, VALUE d) {
     ret = virDomainSnapshotCreateXML(domain_get(d), StringValueCStr(xmlDesc),
                                      NUM2UINT(flags));
 
-    _E(ret == NULL, create_error(e_Error, "virDomainSnapshotCreateXML", "", conn(d)));
+    _E(ret == NULL, create_error(e_Error, "virDomainSnapshotCreateXML",
+                                 conn(d)));
 
     return domain_snapshot_new(ret, d);
 }
 
 /*
  * call-seq:
- *   dom.num_of_snapshots -> fixnum
+ *   dom.num_of_snapshots(flags=0) -> fixnum
  *
  * Call +virDomainSnapshotNum+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSnapshotNum]
+ * to retrieve the number of available snapshots for this domain.
  */
 static VALUE libvirt_dom_num_of_snapshots(int argc, VALUE *argv, VALUE d) {
-    int result;
-    virDomainPtr dom = domain_get(d);
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
@@ -1079,61 +1246,56 @@ static VALUE libvirt_dom_num_of_snapshots(int argc, VALUE *argv, VALUE d) {
     if (NIL_P(flags))
         flags = INT2FIX(0);
 
-    result = virDomainSnapshotNum(dom, NUM2UINT(flags));
-    _E(result < 0, create_error(e_RetrieveError, "virDomainSnapshotNum", "", conn(d)));
-                                                                        \
-    return INT2NUM(result);                                             \
+    gen_call_int(virDomainSnapshotNum, conn(d), domain_get(d),
+                 NUM2UINT(flags));
 }
 
 /*
  * call-seq:
- *   dom.list_snapshots -> list
+ *   dom.list_snapshots(flags=0) -> list
  *
  * Call +virDomainSnapshotListNames+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSnapshotListNames]
+ * to retrieve a list of snapshot names available for this domain.
  */
 static VALUE libvirt_dom_list_snapshots(int argc, VALUE *argv, VALUE d) {
-    VALUE flags;
-    int r, i;
+    VALUE flags_val;
+    int r;
     int num;
     virDomainPtr dom = domain_get(d);
     char **names;
-    VALUE result;
+    unsigned int flags;
 
-    rb_scan_args(argc, argv, "01", &flags);
+    rb_scan_args(argc, argv, "01", &flags_val);
 
-    if (NIL_P(flags))
-        flags = INT2FIX(0);
+    if (NIL_P(flags_val))
+        flags = 0;
+    else
+        flags = NUM2UINT(flags_val);
 
     num = virDomainSnapshotNum(dom, 0);
-    _E(num < 0, create_error(e_RetrieveError, "virDomainSnapshotNum", "", conn(d)));
-    if (num == 0) {
+    _E(num < 0, create_error(e_RetrieveError, "virDomainSnapshotNum", conn(d)));
+    if (num == 0)
         /* if num is 0, don't call virDomainSnapshotListNames function */
-        result = rb_ary_new2(num);
-        return result;
-    }
+        return rb_ary_new2(num);
+
     names = ALLOC_N(char *, num);
 
-    r = virDomainSnapshotListNames(domain_get(d), names, num,
-                                   NUM2UINT(flags));
+    r = virDomainSnapshotListNames(domain_get(d), names, num, flags);
     if (r < 0) {
-        free(names);
-        _E(r < 0, create_error(e_RetrieveError, "virDomainSnapshotListNames", "", conn(d)));
+        xfree(names);
+        rb_exc_raise(create_error(e_RetrieveError, "virDomainSnapshotListNames",
+                                  conn(d)));
     }
 
-    result = rb_ary_new2(num);
-    for (i=0; i<num; i++) {
-        rb_ary_push(result, rb_str_new2(names[i]));
-        free(names[i]);
-    }
-    free(names);
-    return result;
+    return gen_list(num, &names);
 }
 
 /*
  * call-seq:
- *   dom.lookup_snapshot_by_name -> Libvirt::Domain::Snapshot
+ *   dom.lookup_snapshot_by_name(name, flags=0) -> Libvirt::Domain::Snapshot
  *
  * Call +virDomainSnapshotLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSnapshotLookupByName]
+ * to retrieve a snapshot object corresponding to snapshot name.
  */
 static VALUE libvirt_dom_lookup_snapshot_by_name(int argc, VALUE *argv, VALUE d) {
     virDomainPtr dom = domain_get(d);
@@ -1147,16 +1309,18 @@ static VALUE libvirt_dom_lookup_snapshot_by_name(int argc, VALUE *argv, VALUE d)
 
     snap = virDomainSnapshotLookupByName(dom, StringValueCStr(name),
                                          NUM2UINT(flags));
-    _E(dom == NULL, create_error(e_RetrieveError, "virDomainSnapshotLookupByName", "", conn(d)));
+    _E(dom == NULL, create_error(e_RetrieveError,
+                                 "virDomainSnapshotLookupByName", conn(d)));
 
     return domain_snapshot_new(snap, d);
 }
 
 /*
  * call-seq:
- *   dom.has_current_snapshot? -> [true|false]
+ *   dom.has_current_snapshot?(flags=0) -> [true|false]
  *
  * Call +virDomainHasCurrentSnapshot+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainHasCurrentSnapshot]
+ * to find out if this domain has a snapshot active.
  */
 static VALUE libvirt_dom_has_current_snapshot_p(int argc, VALUE *argv, VALUE d) {
     VALUE flags;
@@ -1172,30 +1336,29 @@ static VALUE libvirt_dom_has_current_snapshot_p(int argc, VALUE *argv, VALUE d)
 
 /*
  * call-seq:
- *   dom.revert_to_snapshot -> nil
+ *   dom.revert_to_snapshot(snapshot_object, flags=0) -> nil
  *
  * Call +virDomainRevertToSnapshot+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainRevertToSnapshot]
+ * to restore this domain to a previously saved snapshot.
  */
 static VALUE libvirt_dom_revert_to_snapshot(int argc, VALUE *argv, VALUE d) {
     VALUE snap, flags;
-    int r;
 
     rb_scan_args(argc, argv, "11", &snap, &flags);
 
     if (NIL_P(flags))
         flags = INT2FIX(0);
 
-    r = virDomainRevertToSnapshot(domain_snapshot_get(snap), NUM2UINT(flags));
-    _E(r < 0, create_error(e_RetrieveError, "virDomainRevertToSnapshot", "", conn(d)));
-
-    return Qnil;
+    gen_call_void(virDomainRevertToSnapshot, conn(d),
+                  domain_snapshot_get(snap), NUM2UINT(flags));
 }
 
 /*
  * call-seq:
- *   dom.current_snapshot -> Libvirt::Domain::Snapshot
+ *   dom.current_snapshot(flags=0) -> Libvirt::Domain::Snapshot
  *
  * Call +virDomainCurrentSnapshot+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCurrentSnapshot]
+ * to retrieve the current snapshot for this domain (if any).
  */
 static VALUE libvirt_dom_current_snapshot(int argc, VALUE *argv, VALUE d) {
     VALUE flags;
@@ -1207,16 +1370,18 @@ static VALUE libvirt_dom_current_snapshot(int argc, VALUE *argv, VALUE d) {
         flags = INT2FIX(0);
 
     snap = virDomainSnapshotCurrent(domain_get(d), NUM2UINT(flags));
-    _E(snap == NULL, create_error(e_RetrieveError, "virDomainSnapshotCurrent", "", conn(d)));
+    _E(snap == NULL, create_error(e_RetrieveError, "virDomainSnapshotCurrent",
+                                  conn(d)));
 
     return domain_snapshot_new(snap, d);
 }
 
 /*
  * call-seq:
- *   snapshot.xml_desc -> string
+ *   snapshot.xml_desc(flags=0) -> string
  *
  * Call +virDomainSnapshotGetXMLDesc+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSnapshotGetXMLDesc]
+ * to retrieve the xml description for this snapshot.
  */
 static VALUE libvirt_dom_snapshot_xml_desc(int argc, VALUE *argv, VALUE s) {
     VALUE flags;
@@ -1232,9 +1397,10 @@ static VALUE libvirt_dom_snapshot_xml_desc(int argc, VALUE *argv, VALUE s) {
 
 /*
  * call-seq:
- *   snapshot.delete -> nil
+ *   snapshot.delete(flags=0) -> nil
  *
  * Call +virDomainSnapshotDelete+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSnapshotDelete]
+ * to delete this snapshot.
  */
 static VALUE libvirt_dom_snapshot_delete(int argc, VALUE *argv, VALUE s) {
     VALUE flags;
@@ -1245,7 +1411,7 @@ static VALUE libvirt_dom_snapshot_delete(int argc, VALUE *argv, VALUE s) {
         flags = INT2FIX(0);
 
     gen_call_void(virDomainSnapshotDelete, conn(s),
-                    domain_snapshot_get(s), NUM2UINT(flags));
+                  domain_snapshot_get(s), NUM2UINT(flags));
 }
 
 /*
@@ -1253,6 +1419,8 @@ static VALUE libvirt_dom_snapshot_delete(int argc, VALUE *argv, VALUE s) {
  *   snapshot.free -> nil
  *
  * Call +virDomainSnapshotFree+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSnapshotFree]
+ * to free up the snapshot object.  After this call the snapshot object is
+ * no longer valid.
  */
 static VALUE libvirt_dom_snapshot_free(VALUE s) {
     gen_call_free(DomainSnapshot, s);
@@ -1266,6 +1434,7 @@ static VALUE libvirt_dom_snapshot_free(VALUE s) {
  *   dom.job_info -> Libvirt::Domain::JobInfo
  *
  * Call +virDomainGetJobInfo+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetJobInfo]
+ * to retrieve the current state of the running domain job.
  */
 static VALUE libvirt_dom_job_info(VALUE d) {
     int r;
@@ -1273,7 +1442,7 @@ static VALUE libvirt_dom_job_info(VALUE d) {
     VALUE result;
 
     r = virDomainGetJobInfo(domain_get(d), &info);
-    _E(r < 0, create_error(e_RetrieveError, "virDomainGetJobInfo", "", conn(d)));
+    _E(r < 0, create_error(e_RetrieveError, "virDomainGetJobInfo", conn(d)));
 
     result = rb_class_new_instance(0, NULL, c_domain_job_info);
     rb_iv_set(result, "@type", INT2NUM(info.type));
@@ -1297,6 +1466,7 @@ static VALUE libvirt_dom_job_info(VALUE d) {
  *   dom.abort_job -> nil
  *
  * Call +virDomainAbortJob+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainAbortJob]
+ * to abort the currently running job on this domain.
  */
 static VALUE libvirt_dom_abort_job(VALUE d) {
     gen_call_void(virDomainAbortJob, conn(d), domain_get(d));
@@ -1304,6 +1474,248 @@ static VALUE libvirt_dom_abort_job(VALUE d) {
 
 #endif
 
+/*
+ * call-seq:
+ *   dom.scheduler_type -> [type, #params]
+ *
+ * Call +virDomainGetSchedulerType+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetSchedulerType]
+ * to retrieve the scheduler type used on this domain.
+ */
+static VALUE libvirt_dom_scheduler_type(VALUE d) {
+    int nparams;
+    char *type;
+    VALUE result;
+    int exception = 0;
+    struct rb_ary_push_arg args;
+
+    type = virDomainGetSchedulerType(domain_get(d), &nparams);
+
+    _E(type == NULL, create_error(e_RetrieveError, "virDomainGetSchedulerType",
+                                  conn(d)));
+
+    result = rb_protect(rb_ary_new_wrap, (VALUE)NULL, &exception);
+    if (exception) {
+        free(type);
+        rb_jump_tag(exception);
+    }
+
+    args.arr = result;
+    args.value = rb_protect(rb_str_new2_wrap, (VALUE)&type, &exception);
+    if (exception) {
+        free(type);
+        rb_jump_tag(exception);
+    }
+    rb_protect(rb_ary_push_wrap, (VALUE)&args, &exception);
+    if (exception) {
+        free(type);
+        rb_jump_tag(exception);
+    }
+
+    args.arr = result;
+    args.value = INT2FIX(nparams);
+    rb_protect(rb_ary_push_wrap, (VALUE)&args, &exception);
+    free(type);
+    if (exception)
+        rb_jump_tag(exception);
+
+    return result;
+}
+
+/*
+ * call-seq:
+ *   dom.scheduler_parameters -> Hash
+ *
+ * Call +virDomainGetSchedulerParameters+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetSchedulerParameters]
+ * to retrieve all of the scheduler parameters for this domain.  The keys and
+ * values in the hash that is returned are hypervisor specific.
+ */
+static VALUE libvirt_dom_scheduler_parameters(VALUE d) {
+    int nparams;
+    char *type;
+    virSchedParameterPtr params;
+    VALUE result;
+    virDomainPtr dom;
+    int r;
+    int i;
+    VALUE val;
+
+    dom = domain_get(d);
+
+    type = virDomainGetSchedulerType(dom, &nparams);
+
+    _E(type == NULL, create_error(e_RetrieveError, "virDomainGetSchedulerType",
+                                  conn(d)));
+
+    xfree(type);
+
+    params = ALLOC_N(virSchedParameter, nparams);
+
+    r = virDomainGetSchedulerParameters(dom, params, &nparams);
+    if (r < 0) {
+        xfree(params);
+        rb_exc_raise(create_error(e_RetrieveError,
+                                  "virDomainGetSchedulerParameters", conn(d)));
+    }
+
+    /* just to shut the compiler up */
+    val = Qnil;
+
+    result = rb_hash_new();
+    for (i = 0; i < nparams; i++) {
+        switch(params[i].type) {
+        case VIR_DOMAIN_SCHED_FIELD_INT:
+            val = INT2FIX(params[i].value.i);
+            break;
+        case VIR_DOMAIN_SCHED_FIELD_UINT:
+            val = UINT2NUM(params[i].value.ui);
+            break;
+        case VIR_DOMAIN_SCHED_FIELD_LLONG:
+            val = LL2NUM(params[i].value.l);
+            break;
+        case VIR_DOMAIN_SCHED_FIELD_ULLONG:
+            val = ULL2NUM(params[i].value.ul);
+            break;
+        case VIR_DOMAIN_SCHED_FIELD_DOUBLE:
+            val = rb_float_new(params[i].value.d);
+            break;
+        case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
+            val = (params[i].value.b == 0) ? Qfalse : Qtrue;
+            break;
+        default:
+            xfree(params);
+            rb_raise(rb_eArgError, "Invalid parameter type");
+        }
+
+        rb_hash_aset(result, rb_str_new2(params[i].field), val);
+    }
+
+    xfree(params);
+
+    return result;
+}
+
+/*
+ * call-seq:
+ *   dom.scheduler_parameters = Hash
+ *
+ * Call +virDomainSetSchedulerParameters+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSetSchedulerParameters]
+ * to set the scheduler parameters for this domain.  The keys and values in
+ * the input hash are hypervisor specific.
+ */
+static VALUE libvirt_dom_scheduler_parameters_set(VALUE d, VALUE input) {
+    int nparams;
+    char *type;
+    virSchedParameterPtr params;
+    virDomainPtr dom;
+    int r;
+    int i;
+    VALUE val;
+
+    Check_Type(input, T_HASH);
+
+    dom = domain_get(d);
+
+    type = virDomainGetSchedulerType(dom, &nparams);
+
+    _E(type == NULL, create_error(e_RetrieveError, "virDomainGetSchedulerType",
+                                  conn(d)));
+
+    xfree(type);
+
+    params = ALLOC_N(virSchedParameter, nparams);
+
+    r = virDomainGetSchedulerParameters(dom, params, &nparams);
+    if (r < 0) {
+        xfree(params);
+        rb_exc_raise(create_error(e_RetrieveError,
+                                  "virDomainGetSchedulerParameters", conn(d)));
+    }
+
+    for (i = 0; i < nparams; i++) {
+        val = rb_hash_aref(input, rb_str_new2(params[i].field));
+
+        switch(params[i].type) {
+        case VIR_DOMAIN_SCHED_FIELD_INT:
+            params[i].value.i = NUM2INT(val);
+            break;
+        case VIR_DOMAIN_SCHED_FIELD_UINT:
+            params[i].value.ui = NUM2UINT(val);
+            break;
+        case VIR_DOMAIN_SCHED_FIELD_LLONG:
+            params[i].value.l = NUM2LL(val);
+            break;
+        case VIR_DOMAIN_SCHED_FIELD_ULLONG:
+            params[i].value.ul = NUM2ULL(val);
+            break;
+        case VIR_DOMAIN_SCHED_FIELD_DOUBLE:
+            params[i].value.d = NUM2DBL(val);
+            break;
+        case VIR_DOMAIN_SCHED_FIELD_BOOLEAN:
+            params[i].value.b = (val == Qtrue) ? 1 : 0;
+            break;
+        default:
+            xfree(params);
+            rb_raise(rb_eArgError, "Invalid parameter type");
+        }
+    }
+
+    r = virDomainSetSchedulerParameters(dom, params, nparams);
+    if (r < 0) {
+        xfree(params);
+        rb_exc_raise(create_error(e_RetrieveError,
+                                  "virDomainSetSchedulerParameters", conn(d)));
+    }
+
+    xfree(params);
+
+    return Qnil;
+}
+
+#if HAVE_VIRDOMAINQEMUMONITORCOMMAND
+/*
+ * call-seq:
+ *   dom.qemu_monitor_command(cmd, flags=0) -> string
+ *
+ * Call virDomainQemuMonitorCommand
+ * to send a qemu command directly to the monitor.  Note that this will only
+ * work on qemu hypervisors, and the input and output formats are not
+ * guaranteed to be stable.  Also note that using this command can severly
+ * impede libvirt's ability to manage the domain; use with caution!
+ */
+static VALUE libvirt_dom_qemu_monitor_command(int argc, VALUE *argv, VALUE d) {
+    VALUE cmd, flags;
+    virDomainPtr dom;
+    char *result;
+    VALUE ret;
+    int exception;
+    virConnectPtr c;
+
+    rb_scan_args(argc, argv, "11", &cmd, &flags);
+
+    if (NIL_P(flags))
+        flags = INT2FIX(0);
+
+    c = conn(d);
+    type = virConnectGetType(c);
+    _E(type == NULL, create_error(e_Error, "virConnectGetType", c));
+    if (strcmp(type, "QEMU") != 0)
+        rb_raise(rb_TypeError, "Tried to use virDomainQemuMonitor command on %s connection", type);
+
+    dom = domain_get(d);
+
+    r = virDomainQemuMonitorCommand(dom, StringValueCStr(cmd), &result,
+                                    NUM2UINT(flags));
+    _E(r < 0, create_error(e_RetrieveError, "virDomainQemuMonitorCommand", c));
+
+    ret = rb_protect(rb_str_new2_wrap, &result, &exception);
+    free(result);
+    if (exception)
+        rb_jump_tag(exception);
+
+    return ret;
+}
+#endif
+
 /*
  * Class Libvirt::Domain
  */
@@ -1311,89 +1723,75 @@ void init_domain()
 {
     c_domain = rb_define_class_under(m_libvirt, "Domain", rb_cObject);
 
-#define DEF_DOMSTATE(name) \
-    rb_define_const(c_domain, #name, INT2NUM(VIR_DOMAIN_##name))
-    /* virDomainState */
-    DEF_DOMSTATE(NOSTATE);
-    DEF_DOMSTATE(RUNNING);
-    DEF_DOMSTATE(BLOCKED);
-    DEF_DOMSTATE(PAUSED);
-    DEF_DOMSTATE(SHUTDOWN);
-    DEF_DOMSTATE(SHUTOFF);
-    DEF_DOMSTATE(CRASHED);
-#undef DEF_DOMSTATE
+    rb_define_const(c_domain, "NOSTATE", INT2NUM(VIR_DOMAIN_NOSTATE));
+    rb_define_const(c_domain, "RUNNING", INT2NUM(VIR_DOMAIN_RUNNING));
+    rb_define_const(c_domain, "BLOCKED", INT2NUM(VIR_DOMAIN_BLOCKED));
+    rb_define_const(c_domain, "PAUSED", INT2NUM(VIR_DOMAIN_PAUSED));
+    rb_define_const(c_domain, "SHUTDOWN", INT2NUM(VIR_DOMAIN_SHUTDOWN));
+    rb_define_const(c_domain, "SHUTOFF", INT2NUM(VIR_DOMAIN_SHUTOFF));
+    rb_define_const(c_domain, "CRASHED", INT2NUM(VIR_DOMAIN_CRASHED));
 
     /* virDomainMigrateFlags */
-#ifdef VIR_MIGRATE_LIVE
+#if HAVE_CONST_VIR_MIGRATE_LIVE
     rb_define_const(c_domain, "MIGRATE_LIVE", INT2NUM(VIR_MIGRATE_LIVE));
 #endif
-#ifdef VIR_MIGRATE_PEER2PEER
+#if HAVE_CONST_VIR_MIGRATE_PEER2PEER
     rb_define_const(c_domain, "MIGRATE_PEER2PEER",
                     INT2NUM(VIR_MIGRATE_PEER2PEER));
 #endif
-#ifdef VIR_MIGRATE_TUNNELLED
+#if HAVE_CONST_VIR_MIGRATE_TUNNELLED
     rb_define_const(c_domain, "MIGRATE_TUNNELLED",
                     INT2NUM(VIR_MIGRATE_TUNNELLED));
 #endif
-#ifdef VIR_MIGRATE_PERSIST_DEST
+#if HAVE_CONST_VIR_MIGRATE_PERSIST_DEST
     rb_define_const(c_domain, "MIGRATE_PERSIST_DEST",
                     INT2NUM(VIR_MIGRATE_PERSIST_DEST));
 #endif
-#ifdef VIR_MIGRATE_UNDEFINE_SOURCE
+#if HAVE_CONST_VIR_MIGRATE_UNDEFINE_SOURCE
     rb_define_const(c_domain, "MIGRATE_UNDEFINE_SOURCE",
                     INT2NUM(VIR_MIGRATE_UNDEFINE_SOURCE));
 #endif
-#ifdef VIR_MIGRATE_PAUSED
+#if HAVE_CONST_VIR_MIGRATE_PAUSED
     rb_define_const(c_domain, "MIGRATE_PAUSED", INT2NUM(VIR_MIGRATE_PAUSED));
 #endif
-#ifdef VIR_MIGRATE_NON_SHARED_DISK
+#if HAVE_CONST_VIR_MIGRATE_NON_SHARED_DISK
     rb_define_const(c_domain, "MIGRATE_NON_SHARED_DISK",
                     INT2NUM(VIR_MIGRATE_NON_SHARED_DISK));
 #endif
-#ifdef VIR_MIGRATE_NON_SHARED_INC
+#if HAVE_CONST_VIR_MIGRATE_NON_SHARED_INC
     rb_define_const(c_domain, "MIGRATE_NON_SHARED_INC",
                     INT2NUM(VIR_MIGRATE_NON_SHARED_INC));
 #endif
-    /* DomainGetXMLDesc flags */
     rb_define_const(c_domain, "DOMAIN_XML_SECURE",
                     INT2NUM(VIR_DOMAIN_XML_SECURE));
     rb_define_const(c_domain, "DOMAIN_XML_INACTIVE",
                     INT2NUM(VIR_DOMAIN_XML_INACTIVE));
-#ifdef VIR_DOMAIN_XML_UPDATE_CPU
+#if HAVE_CONST_VIR_DOMAIN_XML_UPDATE_CPU
     rb_define_const(c_domain, "DOMAIN_XML_UPDATE_CPU",
                     INT2NUM(VIR_DOMAIN_XML_UPDATE_CPU));
 #endif
+#if HAVE_VIRDOMAINMEMORYPEEK
     rb_define_const(c_domain, "MEMORY_VIRTUAL", INT2NUM(VIR_MEMORY_VIRTUAL));
-#ifdef VIR_MEMORY_PHYSICAL
+#endif
+#if HAVE_CONST_VIR_MEMORY_PHYSICAL
     rb_define_const(c_domain, "MEMORY_PHYSICAL", INT2NUM(VIR_MEMORY_PHYSICAL));
 #endif
 
-    // Domain creation/lookup
-    rb_define_method(c_connect, "num_of_domains",
-                     libvirt_conn_num_of_domains, 0);
-    rb_define_method(c_connect, "list_domains", libvirt_conn_list_domains, 0);
-    rb_define_method(c_connect, "num_of_defined_domains",
-                     libvirt_conn_num_of_defined_domains, 0);
-    rb_define_method(c_connect, "list_defined_domains",
-                     libvirt_conn_list_defined_domains, 0);
-    rb_define_method(c_connect, "create_domain_linux",
-                     libvirt_conn_create_linux, -1);
-    rb_define_method(c_connect, "lookup_domain_by_name",
-                     libvirt_conn_lookup_domain_by_name, 1);
-    rb_define_method(c_connect, "lookup_domain_by_id",
-                     libvirt_conn_lookup_domain_by_id, 1);
-    rb_define_method(c_connect, "lookup_domain_by_uuid",
-                     libvirt_conn_lookup_domain_by_uuid, 1);
-    rb_define_method(c_connect, "define_domain_xml",
-                     libvirt_conn_define_domain_xml, 1);
-
-#if HAVE_VIRCONNECTDOMAINXMLFROMNATIVE
-    rb_define_method(c_connect, "domain_xml_from_native",
-                     libvirt_conn_domain_xml_from_native, -1);
+#if HAVE_CONST_VIR_DOMAIN_START_PAUSED
+    rb_define_const(c_domain, "START_PAUSED", INT2NUM(VIR_DOMAIN_START_PAUSED));
 #endif
-#if HAVE_VIRCONNECTDOMAINXMLTONATIVE
-    rb_define_method(c_connect, "domain_xml_to_native",
-                     libvirt_conn_domain_xml_to_native, -1);
+
+#if HAVE_CONST_VIR_DUMP_CRASH
+    rb_define_const(c_domain, "DUMP_CRASH", INT2NUM(VIR_DUMP_CRASH));
+#endif
+#if HAVE_CONST_VIR_DUMP_LIVE
+    rb_define_const(c_domain, "DUMP_LIVE", INT2NUM(VIR_DUMP_LIVE));
+#endif
+
+#if HAVE_VIRDOMAINGETVCPUSFLAGS
+    rb_define_const(c_domain, "VCPU_LIVE", INT2NUM(VIR_DOMAIN_VCPU_LIVE));
+    rb_define_const(c_domain, "VCPU_CONFIG", INT2NUM(VIR_DOMAIN_VCPU_CONFIG));
+    rb_define_const(c_domain, "VCPU_MAXIMUM", INT2NUM(VIR_DOMAIN_VCPU_MAXIMUM));
 #endif
 
     rb_define_method(c_domain, "migrate", libvirt_dom_migrate, -1);
@@ -1413,6 +1811,7 @@ void init_domain()
     rb_define_method(c_domain, "resume", libvirt_dom_resume, 0);
     rb_define_method(c_domain, "save", libvirt_dom_save, 1);
     rb_define_singleton_method(c_domain, "restore", libvirt_dom_s_restore, 2);
+    rb_define_method(c_domain, "restore", libvirt_dom_restore, 1);
     rb_define_method(c_domain, "core_dump", libvirt_dom_core_dump, -1);
     rb_define_method(c_domain, "info", libvirt_dom_info, 0);
     rb_define_method(c_domain, "ifinfo", libvirt_dom_if_stats, 1);
@@ -1425,31 +1824,46 @@ void init_domain()
     rb_define_method(c_domain, "memory=", libvirt_dom_memory_set, 1);
     rb_define_method(c_domain, "max_vcpus", libvirt_dom_max_vcpus, 0);
     rb_define_method(c_domain, "vcpus=", libvirt_dom_vcpus_set, 1);
+#if HAVE_VIRDOMAINSETVCPUSFLAGS
+    rb_define_method(c_domain, "vcpus_flags=", libvirt_dom_vcpus_set_flags, 1);
+#endif
     rb_define_method(c_domain, "pin_vcpu", libvirt_dom_pin_vcpu, 2);
     rb_define_method(c_domain, "xml_desc", libvirt_dom_xml_desc, -1);
     rb_define_method(c_domain, "undefine", libvirt_dom_undefine, 0);
-    rb_define_method(c_domain, "create", libvirt_dom_create, 0);
+    rb_define_method(c_domain, "create", libvirt_dom_create, -1);
     rb_define_method(c_domain, "autostart", libvirt_dom_autostart, 0);
     rb_define_method(c_domain, "autostart?", libvirt_dom_autostart, 0);
     rb_define_method(c_domain, "autostart=", libvirt_dom_autostart_set, 1);
     rb_define_method(c_domain, "free", libvirt_dom_free, 0);
-    /* FIXME: we should probably allow a "flags" parameter to
-     * {attach,detach}_device, and then call
-     * virDomain{Attach,Detach}DeviceFlags, where appropriate
-     *
-     * We should also make the VIR_DOMAIN_DEVICE_MODIFY_* flags consts
-     */
-    rb_define_method(c_domain, "attach_device", libvirt_dom_attach_device, 1);
-    rb_define_method(c_domain, "detach_device", libvirt_dom_detach_device, 1);
-    /* FIXME: implement this */
-    // rb_define_method(c_domain, "update_device", libvirt_dom_update_device, -1);
-    /* FIXME: we should probably do scheduler parameters as hashes.  That is
-     * virDomainGetSchedulerParameters should return a hash with all of the
-     * parameters, and virDomainSetSchedulerParameters should take a hash
-     * of parameters in
-     */
-    //rb_define_method(c_domain, "get_scheduler_params", libvirt_dom_get_scheduler_params, 0);
-    //rb_define_method(c_domain, "set_scheduler_params", libvirt_dom_set_scheduler_params, 0)
+
+#if HAVE_CONST_VIR_DOMAIN_DEVICE_MODIFY_CURRENT
+    rb_define_const(c_domain, "DEVICE_MODIFY_CURRENT",
+                    INT2NUM(VIR_DOMAIN_DEVICE_MODIFY_CURRENT));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_DEVICE_MODIFY_LIVE
+    rb_define_const(c_domain, "DEVICE_MODIFY_LIVE",
+                    INT2NUM(VIR_DOMAIN_DEVICE_MODIFY_LIVE));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_DEVICE_MODIFY_CONFIG
+    rb_define_const(c_domain, "DEVICE_MODIFY_CONFIG",
+                    INT2NUM(VIR_DOMAIN_DEVICE_MODIFY_CONFIG));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_DEVICE_MODIFY_FORCE
+    rb_define_const(c_domain, "DEVICE_MODIFY_FORCE",
+                    INT2NUM(VIR_DOMAIN_DEVICE_MODIFY_FORCE));
+#endif
+    rb_define_method(c_domain, "attach_device", libvirt_dom_attach_device, -1);
+    rb_define_method(c_domain, "detach_device", libvirt_dom_detach_device, -1);
+#if HAVE_VIRDOMAINUPDATEDEVICEFLAGS
+    rb_define_method(c_domain, "update_device", libvirt_dom_update_device, -1);
+#endif
+
+    rb_define_method(c_domain, "scheduler_type", libvirt_dom_scheduler_type, 0);
+    rb_define_method(c_domain, "scheduler_parameters",
+                     libvirt_dom_scheduler_parameters, 0);
+    rb_define_method(c_domain, "scheduler_parameters=",
+                     libvirt_dom_scheduler_parameters_set, 1);
+
 #if HAVE_VIRDOMAINMANAGEDSAVE
     rb_define_method(c_domain, "managed_save", libvirt_dom_managed_save, -1);
     rb_define_method(c_domain, "has_managed_save?",
@@ -1457,19 +1871,24 @@ void init_domain()
     rb_define_method(c_domain, "managed_save_remove",
                      libvirt_dom_managed_save_remove, -1);
 #endif
+#if HAVE_VIRDOMAINGETSECURITYLABEL
     rb_define_method(c_domain, "security_label",
                      libvirt_dom_security_label, 0);
+#endif
     rb_define_method(c_domain, "block_stats", libvirt_dom_block_stats, 1);
 #if HAVE_TYPE_VIRDOMAINMEMORYSTATPTR
     rb_define_method(c_domain, "memory_stats", libvirt_dom_memory_stats, -1);
 #endif
+#if HAVE_VIRDOMAINBLOCKPEEK
     rb_define_method(c_domain, "block_peek", libvirt_dom_block_peek, -1);
+#endif
 #if HAVE_TYPE_VIRDOMAINBLOCKINFOPTR
     rb_define_method(c_domain, "blockinfo", libvirt_dom_block_info, -1);
 #endif
+#if HAVE_VIRDOMAINMEMORYPEEK
     rb_define_method(c_domain, "memory_peek", libvirt_dom_memory_peek, -1);
-    /* FIXME: implement these */
-    //rb_define_method(c_domain, "get_vcpus", libvirt_dom_get_vcpus, 0);
+#endif
+    rb_define_method(c_domain, "get_vcpus", libvirt_dom_get_vcpus, 0);
 #if HAVE_VIRDOMAINISACTIVE
     rb_define_method(c_domain, "active?", libvirt_dom_active_p, 0);
 #endif
@@ -1544,6 +1963,21 @@ void init_domain()
                                                   rb_cObject);
     rb_define_attr(c_domain_memory_stats, "tag", 1, 0);
     rb_define_attr(c_domain_memory_stats, "value", 1, 0);
+
+    rb_define_const(c_domain_memory_stats, "SWAP_IN",
+                    INT2NUM(VIR_DOMAIN_MEMORY_STAT_SWAP_IN));
+    rb_define_const(c_domain_memory_stats, "SWAP_OUT",
+                    INT2NUM(VIR_DOMAIN_MEMORY_STAT_SWAP_OUT));
+    rb_define_const(c_domain_memory_stats, "MAJOR_FAULT",
+                    INT2NUM(VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT));
+    rb_define_const(c_domain_memory_stats, "MINOR_FAULT",
+                    INT2NUM(VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT));
+    rb_define_const(c_domain_memory_stats, "UNUSED",
+                    INT2NUM(VIR_DOMAIN_MEMORY_STAT_UNUSED));
+    rb_define_const(c_domain_memory_stats, "AVAILABLE",
+                    INT2NUM(VIR_DOMAIN_MEMORY_STAT_AVAILABLE));
+    rb_define_const(c_domain_memory_stats, "NR",
+                    INT2NUM(VIR_DOMAIN_MEMORY_STAT_NR));
 #endif
 
 #if HAVE_TYPE_VIRDOMAINBLOCKINFOPTR
@@ -1571,6 +2005,19 @@ void init_domain()
     rb_define_method(c_domain_snapshot, "free", libvirt_dom_snapshot_free, 0);
 #endif
 
+    /*
+     * Class Libvirt::Domain::VCPUInfo
+     */
+    c_domain_vcpuinfo = rb_define_class_under(c_domain, "VCPUInfo", rb_cObject);
+    rb_define_const(c_domain_vcpuinfo, "OFFLINE", VIR_VCPU_OFFLINE);
+    rb_define_const(c_domain_vcpuinfo, "RUNNING", VIR_VCPU_RUNNING);
+    rb_define_const(c_domain_vcpuinfo, "BLOCKED", VIR_VCPU_BLOCKED);
+    rb_define_attr(c_domain_vcpuinfo, "number", 1, 0);
+    rb_define_attr(c_domain_vcpuinfo, "state", 1, 0);
+    rb_define_attr(c_domain_vcpuinfo, "cpu_time", 1, 0);
+    rb_define_attr(c_domain_vcpuinfo, "cpu", 1, 0);
+    rb_define_attr(c_domain_vcpuinfo, "cpumap", 1, 0);
+
 #if HAVE_TYPE_VIRDOMAINJOBINFOPTR
     /*
      * Class Libvirt::Domain::JobInfo
@@ -1603,4 +2050,13 @@ void init_domain()
     rb_define_method(c_domain, "job_info", libvirt_dom_job_info, 0);
     rb_define_method(c_domain, "abort_job", libvirt_dom_abort_job, 0);
 #endif
+
+#if HAVE_VIRDOMAINQEMUMONITORCOMMAND
+    rb_define_method(c_domain, "qemu_monitor_command",
+                     libvirt_dom_qemu_monitor_command, -1);
+#endif
+
+#if HAVE_VIRDOMAINGETVCPUSFLAGS
+    rb_define_method(c_domain, "num_vcpus", libvirt_dom_num_vcpus, 1);
+#endif
 }