ruby-libvirt 0.3.0 → 0.4.0

data/ext/libvirt/domain.c

@@ -18,7 +18,9 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  */
 
+#include <stdint.h>
 #include <ruby.h>
+#include <st.h>
 #include <libvirt/libvirt.h>
 #if HAVE_VIRDOMAINQEMUMONITORCOMMAND
 #include <libvirt/libvirt-qemu.h>
@@ -27,8 +29,35 @@
 #include "common.h"
 #include "connect.h"
 #include "extconf.h"
+#include "stream.h"
+
+#ifndef HAVE_TYPE_VIRTYPEDPARAMETERPTR
+#define VIR_TYPED_PARAM_INT VIR_DOMAIN_SCHED_FIELD_INT
+#define VIR_TYPED_PARAM_UINT VIR_DOMAIN_SCHED_FIELD_UINT
+#define VIR_TYPED_PARAM_LLONG VIR_DOMAIN_SCHED_FIELD_LLONG
+#define VIR_TYPED_PARAM_ULLONG VIR_DOMAIN_SCHED_FIELD_ULLONG
+#define VIR_TYPED_PARAM_DOUBLE VIR_DOMAIN_SCHED_FIELD_DOUBLE
+#define VIR_TYPED_PARAM_BOOLEAN VIR_DOMAIN_SCHED_FIELD_BOOLEAN
+
+#define VIR_TYPED_PARAM_FIELD_LENGTH 80
+typedef struct _virTypedParameter virTypedParameter;
+struct _virTypedParameter {
+    char field[VIR_TYPED_PARAM_FIELD_LENGTH];  /* parameter name */
+    int type;   /* parameter type, virTypedParameterType */
+    union {
+        int i;                      /* type is INT */
+        unsigned int ui;            /* type is UINT */
+        long long int l;            /* type is LLONG */
+        unsigned long long int ul;  /* type is ULLONG */
+        double d;                   /* type is DOUBLE */
+        char b;                     /* type is BOOLEAN */
+    } value; /* parameter value */
+};
+typedef virTypedParameter *virTypedParameterPtr;
 
-VALUE c_domain;
+#endif
+
+static VALUE c_domain;
 static VALUE c_domain_info;
 static VALUE c_domain_ifinfo;
 static VALUE c_domain_security_label;
@@ -47,7 +76,7 @@ static VALUE c_domain_job_info;
 #endif
 static VALUE c_domain_vcpuinfo;
 
-void domain_free(void *d) {
+static void domain_free(void *d) {
     generic_free(Domain, d);
 }
 
@@ -75,9 +104,9 @@ static VALUE libvirt_dom_migrate(int argc, VALUE *argv, VALUE s) {
                  &bandwidth);
 
     if (NIL_P(bandwidth))
-        bandwidth = INT2FIX(0);
+        bandwidth = INT2NUM(0);
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     ddom = virDomainMigrate(domain_get(s), conn(dconn), NUM2ULONG(flags),
                             get_string_or_nil(dname_val),
@@ -98,18 +127,18 @@ static VALUE libvirt_dom_migrate(int argc, VALUE *argv, VALUE s) {
  * libvirt URI is duri.
  */
 static VALUE libvirt_dom_migrate_to_uri(int argc, VALUE *argv, VALUE s) {
-    VALUE flags, dname_val, bandwidth, duri_val;
+    VALUE duri, flags, dname, bandwidth;
 
-    rb_scan_args(argc, argv, "13", &duri_val, &flags, &dname_val, &bandwidth);
+    rb_scan_args(argc, argv, "13", &duri, &flags, &dname, &bandwidth);
 
     if (NIL_P(bandwidth))
-        bandwidth = INT2FIX(0);
+        bandwidth = INT2NUM(0);
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_void(virDomainMigrateToURI, conn(s), domain_get(s),
-                  StringValueCStr(duri_val), NUM2ULONG(flags),
-                  get_string_or_nil(dname_val), NUM2ULONG(bandwidth));
+                  StringValueCStr(duri), NUM2ULONG(flags),
+                  get_string_or_nil(dname), NUM2ULONG(bandwidth));
 }
 #endif
 
@@ -128,13 +157,89 @@ static VALUE libvirt_dom_migrate_set_max_downtime(int argc, VALUE *argv,
     rb_scan_args(argc, argv, "11", &downtime, &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_void(virDomainMigrateSetMaxDowntime, conn(s), domain_get(s),
                   NUM2ULL(downtime), NUM2UINT(flags));
 }
 #endif
 
+#if HAVE_VIRDOMAINMIGRATE2
+/*
+ * call-seq:
+ *   dom.migrate2(dconn, dxml=nil, flags=0, dname=nil, uri=nil, bandwidth=0) -> Libvirt::Domain
+ *
+ * Call +virDomainMigrate2+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainMigrate2]
+ * to migrate a domain from the host on this connection to the connection
+ * referenced in dconn.
+ */
+static VALUE libvirt_dom_migrate2(int argc, VALUE *argv, VALUE s) {
+    VALUE dconn, dxml, flags, dname_val, uri_val, bandwidth;
+    virDomainPtr ddom = NULL;
+
+    rb_scan_args(argc, argv, "15", &dconn, &dxml, &flags, &dname_val, &uri_val,
+                 &bandwidth);
+
+    if (NIL_P(bandwidth))
+        bandwidth = INT2NUM(0);
+    if (NIL_P(flags))
+        flags = INT2NUM(0);
+
+    ddom = virDomainMigrate2(domain_get(s), conn(dconn),
+                             get_string_or_nil(dxml), NUM2ULONG(flags),
+                             get_string_or_nil(dname_val),
+                             get_string_or_nil(uri_val), NUM2ULONG(bandwidth));
+
+    _E(ddom == NULL, create_error(e_Error, "virDomainMigrate2", conn(s)));
+
+    return domain_new(ddom, dconn);
+}
+
+/*
+ * call-seq:
+ *   dom.migrate_to_uri2(duri=nil, migrate_uri=nil, dxml=nil, flags=0, dname=nil, bandwidth=0) -> nil
+ *
+ * Call +virDomainMigrateToURI2+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainMigrateToURI2]
+ * to migrate a domain from the host on this connection to the host whose
+ * libvirt URI is duri.
+ */
+static VALUE libvirt_dom_migrate_to_uri2(int argc, VALUE *argv, VALUE s) {
+    VALUE duri, migrate_uri, dxml, flags, dname, bandwidth;
+
+    rb_scan_args(argc, argv, "06", &duri, &migrate_uri, &dxml, &flags, &dname,
+                 &bandwidth);
+
+    if (NIL_P(bandwidth))
+        bandwidth = INT2NUM(0);
+    if (NIL_P(flags))
+        flags = INT2NUM(0);
+
+    gen_call_void(virDomainMigrateToURI2, conn(s), domain_get(s),
+                  get_string_or_nil(duri), get_string_or_nil(migrate_uri),
+                  get_string_or_nil(dxml), NUM2ULONG(flags),
+                  get_string_or_nil(dname), NUM2ULONG(bandwidth));
+}
+
+/*
+ * call-seq:
+ *   dom.migrate_set_max_speed(bandwidth, flags=0) -> nil
+ *
+ * Call +virDomainMigrateSetMaxSpeed+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainMigrateSetMaxSpeed]
+ * to set the maximum bandwidth allowed for live migration.
+ */
+static VALUE libvirt_dom_migrate_set_max_speed(int argc, VALUE *argv, VALUE s) {
+    VALUE bandwidth, flags;
+
+    rb_scan_args(argc, argv, "11", &bandwidth, &flags);
+
+    if (NIL_P(flags))
+        flags = INT2NUM(0);
+
+    gen_call_void(virDomainMigrateSetMaxSpeed, conn(s), domain_get(s),
+                  NUM2ULONG(bandwidth), NUM2UINT(flags));
+}
+#endif
+
 /*
  * call-seq:
  *   dom.shutdown -> nil
@@ -161,7 +266,7 @@ static VALUE libvirt_dom_reboot(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_void(virDomainReboot, conn(s), domain_get(s), NUM2UINT(flags));
 }
@@ -228,7 +333,7 @@ static VALUE libvirt_dom_managed_save(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_void(virDomainManagedSave, conn(s), domain_get(s),
                   NUM2UINT(flags));
@@ -247,7 +352,7 @@ static VALUE libvirt_dom_has_managed_save(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_truefalse(virDomainHasManagedSaveImage, conn(s), domain_get(s),
                        NUM2UINT(flags));
@@ -266,7 +371,7 @@ static VALUE libvirt_dom_managed_save_remove(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_void(virDomainManagedSaveRemove, conn(s), domain_get(s),
                   NUM2UINT(flags));
@@ -286,7 +391,7 @@ static VALUE libvirt_dom_core_dump(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "11", &to, &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_void(virDomainCoreDump, conn(s), domain_get(s),
                   StringValueCStr(to), NUM2INT(flags));
@@ -336,7 +441,7 @@ static VALUE libvirt_dom_info(VALUE s) {
     rb_iv_set(result, "@state", CHR2FIX(info.state));
     rb_iv_set(result, "@max_mem", ULONG2NUM(info.maxMem));
     rb_iv_set(result, "@memory", ULONG2NUM(info.memory));
-    rb_iv_set(result, "@nr_virt_cpu", INT2FIX((int) info.nrVirtCpu));
+    rb_iv_set(result, "@nr_virt_cpu", INT2NUM((int) info.nrVirtCpu));
     rb_iv_set(result, "@cpu_time", ULL2NUM(info.cpuTime));
 
     return result;
@@ -414,7 +519,7 @@ static VALUE libvirt_dom_memory_stats(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     r = virDomainMemoryStats(dom, stats, 6, NUM2UINT(flags));
     _E(r < 0, create_error(e_RetrieveError, "virDomainMemoryStats", conn(s)));
@@ -461,7 +566,7 @@ static VALUE libvirt_dom_block_info(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "11", &path, &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     r = virDomainGetBlockInfo(dom, StringValueCStr(path), &info,
                               NUM2UINT(flags));
@@ -502,7 +607,7 @@ static VALUE libvirt_dom_block_peek(int argc, VALUE *argv, VALUE s) {
                  &flags_val);
 
     if (NIL_P(flags_val))
-        flags_val = INT2FIX(0);
+        flags_val = INT2NUM(0);
 
     path = StringValueCStr(path_val);
     offset = NUM2ULL(offset_val);
@@ -554,7 +659,7 @@ static VALUE libvirt_dom_memory_peek(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "21", &start_val, &size_val, &flags_val);
 
     if (NIL_P(flags_val))
-        flags_val = INT2FIX(VIR_MEMORY_VIRTUAL);
+        flags_val = INT2NUM(VIR_MEMORY_VIRTUAL);
 
     start = NUM2UINT(start_val);
     size = NUM2UINT(size_val);
@@ -581,6 +686,46 @@ static VALUE libvirt_dom_memory_peek(int argc, VALUE *argv, VALUE s) {
 }
 #endif
 
+struct create_vcpu_array_args {
+    virVcpuInfoPtr cpuinfo;
+    unsigned char *cpumap;
+    int nr_virt_cpu;
+    int maxcpus;
+};
+
+static VALUE create_vcpu_array(VALUE input) {
+    struct create_vcpu_array_args *args;
+    VALUE result;
+    int i;
+    VALUE vcpuinfo;
+    VALUE p2vcpumap;
+    int j;
+
+    args = (struct create_vcpu_array_args *)input;
+
+    result = rb_ary_new();
+
+    for (i = 0; i < args->nr_virt_cpu; i++) {
+        vcpuinfo = rb_class_new_instance(0, NULL, c_domain_vcpuinfo);
+        rb_iv_set(vcpuinfo, "@number", UINT2NUM((args->cpuinfo)[i].number));
+        rb_iv_set(vcpuinfo, "@state", INT2NUM((args->cpuinfo)[i].state));
+        rb_iv_set(vcpuinfo, "@cpu_time", ULL2NUM((args->cpuinfo)[i].cpuTime));
+        rb_iv_set(vcpuinfo, "@cpu", INT2NUM((args->cpuinfo)[i].cpu));
+
+        p2vcpumap = rb_ary_new();
+
+        for (j = 0; j < args->maxcpus; j++)
+            rb_ary_push(p2vcpumap,
+                        (VIR_CPU_USABLE(args->cpumap,
+                                        VIR_CPU_MAPLEN(args->maxcpus), i, j)) ? Qtrue : Qfalse);
+        rb_iv_set(vcpuinfo, "@cpumap", p2vcpumap);
+
+        rb_ary_push(result, vcpuinfo);
+    }
+
+    return result;
+}
+
 /* call-seq:
  *   dom.get_vcpus -> [ Libvirt::Domain::VCPUInfo ]
  *
@@ -594,14 +739,10 @@ static VALUE libvirt_dom_get_vcpus(VALUE s) {
     virVcpuInfoPtr cpuinfo;
     unsigned char *cpumap;
     int cpumaplen;
-    int r, i, j;
-    VALUE vcpuinfo;
-    VALUE p2vcpumap;
+    int r;
     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;
+    struct create_vcpu_array_args args;
 
     r = virNodeGetInfo(conn(s), &nodeinfo);
     _E(r < 0, create_error(e_RetrieveError, "virNodeGetInfo", conn(s)));
@@ -630,97 +771,17 @@ static VALUE libvirt_dom_get_vcpus(VALUE s) {
                                   conn(s)));
     }
 
-    result = rb_protect(rb_ary_new_wrap, (VALUE)NULL, &exception);
+    args.cpuinfo = cpuinfo;
+    args.cpumap = cpumap;
+    args.nr_virt_cpu = dominfo.nrVirtCpu;
+    args.maxcpus = VIR_NODEINFO_MAXCPUS(nodeinfo);
+    result = rb_protect(create_vcpu_array, (VALUE)&args, &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);
 
@@ -811,13 +872,12 @@ static VALUE libvirt_dom_id(VALUE s) {
     int out;
 
     id = virDomainGetID(dom);
-    _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
      */
     out = id;
+    _E(out == -1, create_error(e_RetrieveError, "virDomainGetID", conn(s)));
 
     return INT2NUM(out);
 }
@@ -893,19 +953,44 @@ static VALUE libvirt_dom_max_memory_set(VALUE s, VALUE max_memory) {
 
 /*
  * call-seq:
- *   dom.memory = Fixnum
+ *   dom.memory = Fixnum,flags=0
  *
  * 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) {
+static VALUE libvirt_dom_memory_set(VALUE s, VALUE in) {
+    VALUE memory;
+    VALUE flags;
     virDomainPtr dom = domain_get(s);
     int r;
 
+    if (TYPE(in) == T_FIXNUM) {
+        memory = in;
+        flags = INT2NUM(0);
+    }
+    else if (TYPE(in) == T_ARRAY) {
+        if (RARRAY_LEN(in) != 2)
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)",
+                     RARRAY_LEN(in));
+        memory = rb_ary_entry(in, 0);
+        flags = rb_ary_entry(in, 1);
+    }
+    else
+        rb_raise(rb_eTypeError,
+                 "wrong argument type (expected Number or Array)");
+
+#if HAVE_VIRDOMAINSETMEMORYFLAGS
+    r = virDomainSetMemoryFlags(dom, NUM2ULONG(memory), NUM2UINT(flags));
+    _E(r < 0, create_error(e_DefinitionError, "virDomainSetMemoryFlags",
+                           conn(s)));
+#else
+    if (NUM2UINT(flags) != 0)
+        rb_raise(e_NoSupportError, "Non-zero flags not supported");
     r = virDomainSetMemory(dom, NUM2ULONG(memory));
     _E(r < 0, create_error(e_DefinitionError, "virDomainSetMemory", conn(s)));
+#endif
 
     return ULONG2NUM(memory);
 }
@@ -964,7 +1049,7 @@ static VALUE libvirt_dom_vcpus_set_flags(VALUE s, VALUE vcpus) {
     Check_Type(vcpus, T_ARRAY);
 
     if (RARRAY_LEN(vcpus) != 2)
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
                  RARRAY_LEN(vcpus));
 
     nvcpus = rb_ary_entry(vcpus, 0);
@@ -1028,7 +1113,7 @@ static VALUE libvirt_dom_xml_desc(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_string(virDomainGetXMLDesc, conn(s), 1, domain_get(s),
                     NUM2INT(flags));
@@ -1059,10 +1144,11 @@ static VALUE libvirt_dom_create(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
 #if HAVE_VIRDOMAINCREATEWITHFLAGS
-    gen_call_void(virDomainCreateWithFlags, conn(s), domain_get(s), NUM2UINT(flags));
+    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");
@@ -1117,7 +1203,7 @@ static VALUE libvirt_dom_attach_device(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
 #if HAVE_VIRDOMAINATTACHDEVICEFLAGS
     gen_call_void(virDomainAttachDeviceFlags, conn(s), domain_get(s),
@@ -1144,7 +1230,7 @@ static VALUE libvirt_dom_detach_device(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
 #if HAVE_VIRDOMAINDETACHDEVICEFLAGS
     gen_call_void(virDomainDetachDeviceFlags, conn(s), domain_get(s),
@@ -1172,7 +1258,7 @@ static VALUE libvirt_dom_update_device(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_void(virDomainUpdateDeviceFlags, conn(s), domain_get(s),
                   StringValueCStr(xml), NUM2UINT(flags));
@@ -1220,7 +1306,7 @@ static VALUE libvirt_dom_snapshot_create_xml(int argc, VALUE *argv, VALUE d) {
     rb_scan_args(argc, argv, "11", &xmlDesc, &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     ret = virDomainSnapshotCreateXML(domain_get(d), StringValueCStr(xmlDesc),
                                      NUM2UINT(flags));
@@ -1244,7 +1330,7 @@ static VALUE libvirt_dom_num_of_snapshots(int argc, VALUE *argv, VALUE d) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_int(virDomainSnapshotNum, conn(d), domain_get(d),
                  NUM2UINT(flags));
@@ -1305,7 +1391,7 @@ static VALUE libvirt_dom_lookup_snapshot_by_name(int argc, VALUE *argv, VALUE d)
     rb_scan_args(argc, argv, "11", &name, &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     snap = virDomainSnapshotLookupByName(dom, StringValueCStr(name),
                                          NUM2UINT(flags));
@@ -1328,7 +1414,7 @@ static VALUE libvirt_dom_has_current_snapshot_p(int argc, VALUE *argv, VALUE d)
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_truefalse(virDomainHasCurrentSnapshot, conn(d), domain_get(d),
                        NUM2UINT(flags));
@@ -1347,7 +1433,7 @@ static VALUE libvirt_dom_revert_to_snapshot(int argc, VALUE *argv, VALUE d) {
     rb_scan_args(argc, argv, "11", &snap, &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_void(virDomainRevertToSnapshot, conn(d),
                   domain_snapshot_get(snap), NUM2UINT(flags));
@@ -1367,7 +1453,7 @@ static VALUE libvirt_dom_current_snapshot(int argc, VALUE *argv, VALUE d) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     snap = virDomainSnapshotCurrent(domain_get(d), NUM2UINT(flags));
     _E(snap == NULL, create_error(e_RetrieveError, "virDomainSnapshotCurrent",
@@ -1389,7 +1475,7 @@ static VALUE libvirt_dom_snapshot_xml_desc(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_string(virDomainSnapshotGetXMLDesc, conn(s), 1,
                     domain_snapshot_get(s), NUM2UINT(flags));
@@ -1408,7 +1494,7 @@ static VALUE libvirt_dom_snapshot_delete(int argc, VALUE *argv, VALUE s) {
     rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(0);
 
     gen_call_void(virDomainSnapshotDelete, conn(s),
                   domain_snapshot_get(s), NUM2UINT(flags));
@@ -1474,6 +1560,24 @@ static VALUE libvirt_dom_abort_job(VALUE d) {
 
 #endif
 
+struct create_sched_type_args {
+    char *type;
+    int nparams;
+};
+
+static VALUE create_sched_type_array(VALUE input) {
+    struct create_sched_type_args *args;
+    VALUE result;
+
+    args = (struct create_sched_type_args *)input;
+
+    result = rb_ary_new();
+    rb_ary_push(result, rb_str_new2(args->type));
+    rb_ary_push(result, INT2NUM(args->nparams));
+
+    return result;
+}
+
 /*
  * call-seq:
  *   dom.scheduler_type -> [type, #params]
@@ -1486,107 +1590,166 @@ static VALUE libvirt_dom_scheduler_type(VALUE d) {
     char *type;
     VALUE result;
     int exception = 0;
-    struct rb_ary_push_arg args;
+    struct create_sched_type_args 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);
+    args.type = type;
+    args.nparams = nparams;
+    result = rb_protect(create_sched_type_array, (VALUE)&args, &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);
-    }
+    return result;
+}
+
+#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;
+    char *result;
+    VALUE ret;
+    int exception;
+    virConnectPtr c;
+    const char *type;
+    int r;
+
+    rb_scan_args(argc, argv, "11", &cmd, &flags);
+
+    if (NIL_P(flags))
+        flags = INT2NUM(0);
+
+    c = conn(d);
+    type = virConnectGetType(c);
+    _E(type == NULL, create_error(e_Error, "virConnectGetType", c));
+    if (strcmp(type, "QEMU") != 0)
+        rb_raise(rb_eTypeError,
+                 "Tried to use virDomainQemuMonitor command on %s connection",
+                 type);
+
+    r = virDomainQemuMonitorCommand(domain_get(d), StringValueCStr(cmd),
+                                    &result, NUM2UINT(flags));
+    _E(r < 0, create_error(e_RetrieveError, "virDomainQemuMonitorCommand", c));
 
-    args.arr = result;
-    args.value = INT2FIX(nparams);
-    rb_protect(rb_ary_push_wrap, (VALUE)&args, &exception);
-    free(type);
+    ret = rb_protect(rb_str_new2_wrap, (VALUE)&result, &exception);
+    free(result);
     if (exception)
         rb_jump_tag(exception);
 
-    return result;
+    return ret;
 }
+#endif
 
+#if HAVE_VIRDOMAINISUPDATED
 /*
  * 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.
+ *   dom.updated? ->  [True|False]
+ * Call +virDomainIsUpdated+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainIsUpdated]
+ * to determine whether the definition for this domain has been updated.
  */
-static VALUE libvirt_dom_scheduler_parameters(VALUE d) {
+static VALUE libvirt_dom_is_updated(VALUE d) {
+    gen_call_truefalse(virDomainIsUpdated, conn(d), domain_get(d));
+}
+#endif
+
+struct field_to_value {
+    VALUE result;
+    virTypedParameterPtr param;
+};
+
+static VALUE typed_field_to_value(VALUE input) {
+    struct field_to_value *ftv = (struct field_to_value *)input;
+    VALUE val;
+
+    switch(ftv->param->type) {
+    case VIR_TYPED_PARAM_INT:
+        val = INT2NUM(ftv->param->value.i);
+        break;
+    case VIR_TYPED_PARAM_UINT:
+        val = UINT2NUM(ftv->param->value.ui);
+        break;
+    case VIR_TYPED_PARAM_LLONG:
+        val = LL2NUM(ftv->param->value.l);
+        break;
+    case VIR_TYPED_PARAM_ULLONG:
+        val = ULL2NUM(ftv->param->value.ul);
+        break;
+    case VIR_TYPED_PARAM_DOUBLE:
+        val = rb_float_new(ftv->param->value.d);
+        break;
+    case VIR_TYPED_PARAM_BOOLEAN:
+        val = (ftv->param->value.b == 0) ? Qfalse : Qtrue;
+        break;
+    default:
+        rb_raise(rb_eArgError, "Invalid parameter type");
+    }
+
+    rb_hash_aset(ftv->result, rb_str_new2(ftv->param->field), val);
+
+    return Qnil;
+}
+
+static VALUE internal_get_parameters(int argc, VALUE *argv, VALUE d,
+                                     int (*nparams_cb)(VALUE d,
+                                                       unsigned int flags),
+                                     char *(*get_cb)(VALUE d,
+                                                     unsigned int flags,
+                                                     virTypedParameterPtr params,
+                                                     int *nparams)) {
     int nparams;
-    char *type;
-    virSchedParameterPtr params;
+    virTypedParameterPtr params;
     VALUE result;
-    virDomainPtr dom;
-    int r;
     int i;
-    VALUE val;
+    int exception;
+    char *errname;
+    struct field_to_value ftv;
+    unsigned int flags;
+    VALUE flags_val;
 
-    dom = domain_get(d);
+    rb_scan_args(argc, argv, "01", &flags_val);
 
-    type = virDomainGetSchedulerType(dom, &nparams);
+    if (NIL_P(flags_val))
+        flags = 0;
+    else
+        flags = NUM2UINT(flags_val);
 
-    _E(type == NULL, create_error(e_RetrieveError, "virDomainGetSchedulerType",
-                                  conn(d)));
+    nparams = nparams_cb(d, flags);
 
-    xfree(type);
+    result = rb_hash_new();
 
-    params = ALLOC_N(virSchedParameter, nparams);
+    if (nparams == 0)
+        return result;
 
-    r = virDomainGetSchedulerParameters(dom, params, &nparams);
-    if (r < 0) {
+    params = ALLOC_N(virTypedParameter, nparams);
+
+    errname = get_cb(d, flags, params, &nparams);
+    if (errname != NULL) {
         xfree(params);
-        rb_exc_raise(create_error(e_RetrieveError,
-                                  "virDomainGetSchedulerParameters", conn(d)));
+        rb_exc_raise(create_error(e_RetrieveError, errname, 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:
+        ftv.result = result;
+        ftv.param = &params[i];
+        rb_protect(typed_field_to_value, (VALUE)&ftv, &exception);
+        if (exception) {
             xfree(params);
-            rb_raise(rb_eArgError, "Invalid parameter type");
+            rb_jump_tag(exception);
         }
-
-        rb_hash_aset(result, rb_str_new2(params[i].field), val);
     }
 
     xfree(params);
@@ -1594,76 +1757,121 @@ static VALUE libvirt_dom_scheduler_parameters(VALUE d) {
     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) {
+struct value_to_field {
+    virTypedParameterPtr param;
+    VALUE input;
+};
+
+static VALUE typed_value_to_field(VALUE in) {
+    struct value_to_field *vtf = (struct value_to_field *)in;
+    VALUE val;
+
+    val = rb_hash_aref(vtf->input, rb_str_new2(vtf->param->field));
+    if (NIL_P(val))
+        return Qnil;
+
+    switch(vtf->param->type) {
+    case VIR_TYPED_PARAM_INT:
+        vtf->param->value.i = NUM2INT(val);
+        break;
+    case VIR_TYPED_PARAM_UINT:
+        vtf->param->value.ui = NUM2UINT(val);
+        break;
+    case VIR_TYPED_PARAM_LLONG:
+        vtf->param->value.l = NUM2LL(val);
+        break;
+    case VIR_TYPED_PARAM_ULLONG:
+        vtf->param->value.ul = NUM2ULL(val);
+        break;
+    case VIR_TYPED_PARAM_DOUBLE:
+        vtf->param->value.d = NUM2DBL(val);
+        break;
+    case VIR_TYPED_PARAM_BOOLEAN:
+        vtf->param->value.b = (val == Qtrue) ? 1 : 0;
+        break;
+    default:
+        rb_raise(rb_eArgError, "Invalid parameter type");
+    }
+
+    return Qnil;
+}
+
+static VALUE internal_set_parameters(VALUE d, VALUE in,
+                                     int (*nparams_cb)(VALUE d,
+                                                       unsigned int flags),
+                                     char *(*get_cb)(VALUE d,
+                                                     unsigned int flags,
+                                                     virTypedParameterPtr params,
+                                                     int *nparams),
+                                     char *(*set_cb)(VALUE d,
+                                                     unsigned int flags,
+                                                     virTypedParameterPtr params,
+                                                     int nparams)) {
     int nparams;
-    char *type;
-    virSchedParameterPtr params;
-    virDomainPtr dom;
-    int r;
+    virTypedParameterPtr params;
+    int exception;
     int i;
-    VALUE val;
+    char *errname;
+    struct value_to_field vtf;
+    VALUE input;
+    VALUE flags_val;
+    unsigned int flags;
+
+    if (TYPE(in) == T_HASH) {
+        input = in;
+        flags_val = INT2NUM(0);
+    }
+    else if (TYPE(in) == T_ARRAY) {
+        if (RARRAY_LEN(in) != 2)
+            rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)",
+                     RARRAY_LEN(in));
+        input = rb_ary_entry(in, 0);
+        flags_val = rb_ary_entry(in, 1);
+    }
+    else
+        rb_raise(rb_eTypeError, "wrong argument type (expected Hash or Array)");
 
     Check_Type(input, T_HASH);
 
-    dom = domain_get(d);
+    /* we do this up-front for proper argument error checking */
+    flags = NUM2UINT(flags_val);
 
-    type = virDomainGetSchedulerType(dom, &nparams);
+    if (RHASH_SIZE(input) == 0)
+        return Qnil;
 
-    _E(type == NULL, create_error(e_RetrieveError, "virDomainGetSchedulerType",
-                                  conn(d)));
+    /* Complicated.  The below all stems from the fact that we have no way to
+     * have no way to discover what type each parameter should be based on the
+     * be based on the input.  Instead, we ask libvirt to give us the current
+     * us the current parameters and types, and then we replace the values with
+     * the values with the new values.  That way we find out what the old types
+     * what the old types were, and if the new types don't match, libvirt will
+     * throw an error.
+     */
 
-    xfree(type);
+    nparams = nparams_cb(d, flags);
 
-    params = ALLOC_N(virSchedParameter, nparams);
+    params = ALLOC_N(virTypedParameter, nparams);
 
-    r = virDomainGetSchedulerParameters(dom, params, &nparams);
-    if (r < 0) {
+    errname = get_cb(d, flags, params, &nparams);
+    if (errname != NULL) {
         xfree(params);
-        rb_exc_raise(create_error(e_RetrieveError,
-                                  "virDomainGetSchedulerParameters", conn(d)));
+        rb_exc_raise(create_error(e_RetrieveError, errname, 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:
+        vtf.param = &params[i];
+        vtf.input = input;
+        rb_protect(typed_value_to_field, (VALUE)&vtf, &exception);
+        if (exception) {
             xfree(params);
-            rb_raise(rb_eArgError, "Invalid parameter type");
+            rb_jump_tag(exception);
         }
     }
 
-    r = virDomainSetSchedulerParameters(dom, params, nparams);
-    if (r < 0) {
+    errname = set_cb(d, flags, params, nparams);
+    if (errname != NULL) {
         xfree(params);
-        rb_exc_raise(create_error(e_RetrieveError,
-                                  "virDomainSetSchedulerParameters", conn(d)));
+        rb_exc_raise(create_error(e_RetrieveError, errname, conn(d)));
     }
 
     xfree(params);
@@ -1671,48 +1879,303 @@ static VALUE libvirt_dom_scheduler_parameters_set(VALUE d, VALUE input) {
     return Qnil;
 }
 
-#if HAVE_VIRDOMAINQEMUMONITORCOMMAND
+static int scheduler_nparams(VALUE d, unsigned int flags) {
+    int nparams;
+    char *type;
+
+    type = virDomainGetSchedulerType(domain_get(d), &nparams);
+    _E(type == NULL, create_error(e_RetrieveError, "virDomainGetSchedulerType",
+                                  conn(d)));
+    xfree(type);
+
+    return nparams;
+}
+
+static char *scheduler_get(VALUE d, unsigned int flags,
+                           virTypedParameterPtr params, int *nparams) {
+#ifdef HAVE_TYPE_VIRTYPEDPARAMETERPTR
+    if (virDomainGetSchedulerParametersFlags(domain_get(d), params, nparams,
+                                             flags) < 0)
+        return "virDomainGetSchedulerParameters";
+#else
+    if (flags != 0)
+        rb_raise(e_NoSupportError, "Non-zero flags not supported");
+    if (virDomainGetSchedulerParameters(domain_get(d),
+                                        (virSchedParameterPtr)params,
+                                        nparams) < 0)
+        return "virDomainGetSchedulerParameters";
+#endif
+
+    return NULL;
+}
+
+static char *scheduler_set(VALUE d, unsigned int flags,
+                           virTypedParameterPtr params, int nparams) {
+#if HAVE_TYPE_VIRTYPEDPARAMETERPTR
+    if (virDomainSetSchedulerParametersFlags(domain_get(d), params, nparams,
+                                             flags) < 0)
+        return "virDomainSetSchedulerParameters";
+#else
+    if (flags != 0)
+        rb_raise(e_NoSupportError, "Non-zero flags not supported");
+    if (virDomainSetSchedulerParameters(domain_get(d),
+                                        (virSchedParameterPtr)params,
+                                        nparams) < 0)
+        return "virDomainSetSchedulerParameters";
+#endif
+
+    return NULL;
+}
+
 /*
  * call-seq:
- *   dom.qemu_monitor_command(cmd, flags=0) -> string
+ *   dom.scheduler_parameters(flags=0) -> Hash
  *
- * 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!
+ * 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_qemu_monitor_command(int argc, VALUE *argv, VALUE d) {
-    VALUE cmd, flags;
-    virDomainPtr dom;
-    char *result;
-    VALUE ret;
-    int exception;
-    virConnectPtr c;
+static VALUE libvirt_dom_get_scheduler_parameters(int argc, VALUE *argv,
+                                                  VALUE d) {
+    return internal_get_parameters(argc, argv, d, scheduler_nparams,
+                                   scheduler_get);
+}
 
-    rb_scan_args(argc, argv, "11", &cmd, &flags);
+/*
+ * call-seq:
+ *   dom.scheduler_parameters = Hash,flags=0
+ *
+ * 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.  If an empty hash is given, no
+ * changes are made (and no error is raised).
+ */
+static VALUE libvirt_dom_set_scheduler_parameters(VALUE d, VALUE input) {
+    return internal_set_parameters(d, input, scheduler_nparams, scheduler_get,
+                                   scheduler_set);
+}
+
+#if HAVE_VIRDOMAINSETMEMORYPARAMETERS
+static int memory_nparams(VALUE d, unsigned int flags) {
+    int nparams = 0;
+    int ret;
+
+    ret = virDomainGetMemoryParameters(domain_get(d), NULL, &nparams, flags);
+    _E(ret < 0, create_error(e_RetrieveError, "virDomainGetMemoryParameters",
+                             conn(d)));
+
+    return nparams;
+}
+
+static char *memory_get(VALUE d, unsigned int flags,
+                        virTypedParameterPtr params, int *nparams) {
+#ifdef HAVE_TYPE_VIRTYPEDPARAMETERPTR
+    if (virDomainGetMemoryParameters(domain_get(d), params, nparams, flags) < 0)
+#else
+    if (virDomainGetMemoryParameters(domain_get(d),
+                                     (virMemoryParameterPtr)params, nparams,
+                                     flags) < 0)
+#endif
+        return "virDomainGetMemoryParameters";
+
+    return NULL;
+}
+
+static char *memory_set(VALUE d, unsigned int flags,
+                        virTypedParameterPtr params, int nparams) {
+#ifdef HAVE_TYPE_VIRTYPEDPARAMETERPTR
+    if (virDomainSetMemoryParameters(domain_get(d), params, nparams, flags) < 0)
+#else
+    if (virDomainSetMemoryParameters(domain_get(d),
+                                     (virMemoryParameterPtr)params, nparams,
+                                     flags) < 0)
+#endif
+        return "virDomainSetMemoryParameters";
+
+    return NULL;
+}
+
+/*
+ * call-seq:
+ *   dom.memory_parameters(flags=0) -> Hash
+ *
+ * Call +virDomainGetMemoryParameters+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetMemoryParameters]
+ * to retrieve all of the memory parameters for this domain.  The keys and
+ * values in the hash that is returned are hypervisor specific.
+ */
+static VALUE libvirt_dom_get_memory_parameters(int argc, VALUE *argv, VALUE d) {
+    return internal_get_parameters(argc, argv, d, memory_nparams, memory_get);
+}
+
+/*
+ * call-seq:
+ *   dom.memory_parameters = Hash,flags=0
+ *
+ * Call +virDomainSetMemoryParameters+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSetMemoryParameters]
+ * to set the memory parameters for this domain.  The keys and values in
+ * the input hash are hypervisor specific.
+ */
+static VALUE libvirt_dom_set_memory_parameters(VALUE d, VALUE in) {
+    return internal_set_parameters(d, in, memory_nparams, memory_get,
+                                   memory_set);
+}
+#endif
+
+#if HAVE_VIRDOMAINSETBLKIOPARAMETERS
+static int blkio_nparams(VALUE d, unsigned int flags) {
+    int nparams = 0;
+    int ret;
+
+    ret = virDomainGetBlkioParameters(domain_get(d), NULL, &nparams, flags);
+    _E(ret < 0, create_error(e_RetrieveError, "virDomainGetBlkioParameters",
+                             conn(d)));
+
+    return nparams;
+}
+
+static char *blkio_get(VALUE d, unsigned int flags, virTypedParameterPtr params,
+                       int *nparams) {
+#ifdef HAVE_TYPE_VIRTYPEDPARAMETERPTR
+    if (virDomainGetBlkioParameters(domain_get(d), params, nparams, flags) < 0)
+#else
+    if (virDomainGetBlkioParameters(domain_get(d),
+                                    (virBlkioParameterPtr)params, nparams,
+                                    flags) < 0)
+#endif
+        return "virDomainGetBlkioParameters";
+
+    return NULL;
+}
+
+static char *blkio_set(VALUE d, unsigned int flags, virTypedParameterPtr params,
+                       int nparams) {
+#ifdef HAVE_TYPE_VIRTYPEDPARAMETERPTR
+    if (virDomainSetBlkioParameters(domain_get(d), params, nparams, flags) < 0)
+#else
+    if (virDomainSetBlkioParameters(domain_get(d),
+                                    (virBlkioParameterPtr)params, nparams,
+                                    flags) < 0)
+#endif
+        return "virDomainSetBlkioParameters";
+
+    return NULL;
+}
+
+/*
+ * call-seq:
+ *   dom.blkio_parameters(flags=0) -> Hash
+ *
+ * Call +virDomainGetBlkioParameters+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetBlkioParameters]
+ * to retrieve all of the blkio parameters for this domain.  The keys and
+ * values in the hash that is returned are hypervisor specific.
+ */
+static VALUE libvirt_dom_get_blkio_parameters(int argc, VALUE *argv, VALUE d) {
+    return internal_get_parameters(argc, argv, d, blkio_nparams, blkio_get);
+}
+
+/*
+ * call-seq:
+ *   dom.memory_parameters = Hash,flags=0
+ *
+ * Call +virDomainSetBlkioParameters+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSetBlkioParameters]
+ * to set the blkio parameters for this domain.  The keys and values in
+ * the input hash are hypervisor specific.
+ */
+static VALUE libvirt_dom_set_blkio_parameters(VALUE d, VALUE in) {
+    return internal_set_parameters(d, in, blkio_nparams, blkio_get, blkio_set);
+}
+#endif
+
+#if HAVE_VIRDOMAINGETSTATE
+/*
+ * call-seq:
+ *   dom.state(flags=0) -> state, reason
+ *
+ * Call +virDomainGetState+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainGetState]
+ * to get the current state of the domain.
+ */
+static VALUE libvirt_dom_get_state(int argc, VALUE *argv, VALUE d) {
+    VALUE flags;
+    int state, reason;
+    VALUE result;
+    int retval;
+
+    rb_scan_args(argc, argv, "01", &flags);
 
     if (NIL_P(flags))
-        flags = INT2FIX(0);
+        flags = INT2NUM(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);
+    retval = virDomainGetState(domain_get(d), &state, &reason, NUM2INT(flags));
+    _E(retval < 0, create_error(e_Error, "virDomainGetState", conn(d)));
 
-    dom = domain_get(d);
+    result = rb_ary_new();
 
-    r = virDomainQemuMonitorCommand(dom, StringValueCStr(cmd), &result,
-                                    NUM2UINT(flags));
-    _E(r < 0, create_error(e_RetrieveError, "virDomainQemuMonitorCommand", c));
+    rb_ary_push(result, INT2NUM(state));
+    rb_ary_push(result, INT2NUM(reason));
 
-    ret = rb_protect(rb_str_new2_wrap, &result, &exception);
-    free(result);
-    if (exception)
-        rb_jump_tag(exception);
+    return result;
+}
+#endif
 
-    return ret;
+#if HAVE_VIRDOMAINOPENCONSOLE
+/*
+ * call-seq:
+ *   dom.open_console(device, stream, flags=0) -> nil
+ *
+ * Call +virDomainOpenConsole+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainOpenConsole]
+ * to open up a console to device over stream.
+ */
+static VALUE libvirt_dom_open_console(int argc, VALUE *argv, VALUE d) {
+    VALUE dev, st, flags;
+
+    rb_scan_args(argc, argv, "21", &dev, &st, &flags);
+
+    if (NIL_P(flags))
+        flags = INT2NUM(0);
+
+    gen_call_void(virDomainOpenConsole, conn(d), domain_get(d),
+                  StringValueCStr(dev), stream_get(st), NUM2INT(flags));
+}
+#endif
+
+#if HAVE_VIRDOMAINSCREENSHOT
+/*
+ * call-seq:
+ *   dom.screenshot(stream, screen, flags=0) -> nil
+ *
+ * Call +virDomainScreenshot+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainScreenshot]
+ * to take a screenshot of the domain console as a stream.
+ */
+static VALUE libvirt_dom_screenshot(int argc, VALUE *argv, VALUE d) {
+    VALUE st, screen, flags;
+
+    rb_scan_args(argc, argv, "21", &st, &screen, &flags);
+
+    if (NIL_P(flags))
+        flags = INT2NUM(0);
+
+    gen_call_string(virDomainScreenshot, conn(d), 1, domain_get(d),
+                    stream_get(st), NUM2UINT(screen), NUM2UINT(flags));
+}
+#endif
+
+#if HAVE_VIRDOMAININJECTNMI
+/*
+ * call-seq:
+ *   dom.inject_nmi(flags=0) -> nil
+ *
+ * Call +virDomainInjectNMI+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainInjectNMI]
+ * to send an NMI to the guest.
+ */
+static VALUE libvirt_dom_inject_nmi(int argc, VALUE *argv, VALUE d) {
+    VALUE flags;
+
+    rb_scan_args(argc, argv, "01", &flags);
+
+    if (NIL_P(flags))
+        flags = INT2NUM(0);
+
+    gen_call_void(virDomainInjectNMI, conn(d), domain_get(d), NUM2UINT(flags));
 }
 #endif
 
@@ -1803,6 +2266,14 @@ void init_domain()
     rb_define_method(c_domain, "migrate_set_max_downtime",
                      libvirt_dom_migrate_set_max_downtime, -1);
 #endif
+#if HAVE_VIRDOMAINMIGRATE2
+    rb_define_method(c_domain, "migrate2", libvirt_dom_migrate2, -1);
+    rb_define_method(c_domain, "migrate_to_uri2",
+                     libvirt_dom_migrate_to_uri2, -1);
+    rb_define_method(c_domain, "migrate_set_max_speed",
+                     libvirt_dom_migrate_set_max_speed, -1);
+#endif
+
     rb_define_attr(c_domain, "connection", 1, 0);
     rb_define_method(c_domain, "shutdown", libvirt_dom_shutdown, 0);
     rb_define_method(c_domain, "reboot", libvirt_dom_reboot, -1);
@@ -1859,10 +2330,6 @@ void init_domain()
 #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);
@@ -2059,4 +2526,126 @@ void init_domain()
 #if HAVE_VIRDOMAINGETVCPUSFLAGS
     rb_define_method(c_domain, "num_vcpus", libvirt_dom_num_vcpus, 1);
 #endif
+
+#if HAVE_VIRDOMAINISUPDATED
+    rb_define_method(c_domain, "updated?", libvirt_dom_is_updated, 0);
+#endif
+
+#ifdef VIR_DOMAIN_MEMORY_PARAM_UNLIMITED
+    rb_define_const(c_domain, "MEMORY_PARAM_UNLIMITED",
+                    VIR_DOMAIN_MEMORY_PARAM_UNLIMITED);
+#endif
+
+#if HAVE_VIRDOMAINSETMEMORYFLAGS
+    rb_define_const(c_domain, "DOMAIN_MEM_LIVE", INT2NUM(VIR_DOMAIN_MEM_LIVE));
+    rb_define_const(c_domain, "DOMAIN_MEM_CONFIG",
+                    INT2NUM(VIR_DOMAIN_MEM_CONFIG));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_MEM_CURRENT
+    rb_define_const(c_domain, "DOMAIN_MEM_CURRENT",
+                    INT2NUM(VIR_DOMAIN_MEM_CURRENT));
+    rb_define_const(c_domain, "DOMAIN_MEM_MAXIMUM",
+                    INT2NUM(VIR_DOMAIN_MEM_MAXIMUM));
+#endif
+
+    rb_define_method(c_domain, "scheduler_parameters",
+                     libvirt_dom_get_scheduler_parameters, -1);
+    rb_define_method(c_domain, "scheduler_parameters=",
+                     libvirt_dom_set_scheduler_parameters, 1);
+
+#if HAVE_VIRDOMAINSETMEMORYPARAMETERS
+    rb_define_method(c_domain, "memory_parameters",
+                     libvirt_dom_get_memory_parameters, -1);
+    rb_define_method(c_domain, "memory_parameters=",
+                     libvirt_dom_set_memory_parameters, 1);
+#endif
+
+#if HAVE_VIRDOMAINSETBLKIOPARAMETERS
+    rb_define_method(c_domain, "blkio_parameters",
+                     libvirt_dom_get_blkio_parameters, -1);
+    rb_define_method(c_domain, "blkio_parameters=",
+                     libvirt_dom_set_blkio_parameters, 1);
+#endif
+
+#if HAVE_VIRDOMAINGETSTATE
+    rb_define_const(c_domain, "DOMAIN_RUNNING_UNKNOWN",
+                    INT2NUM(VIR_DOMAIN_RUNNING_UNKNOWN));
+    rb_define_const(c_domain, "DOMAIN_RUNNING_BOOTED",
+                    INT2NUM(VIR_DOMAIN_RUNNING_BOOTED));
+    rb_define_const(c_domain, "DOMAIN_RUNNING_MIGRATED",
+                    INT2NUM(VIR_DOMAIN_RUNNING_MIGRATED));
+    rb_define_const(c_domain, "DOMAIN_RUNNING_RESTORED",
+                    INT2NUM(VIR_DOMAIN_RUNNING_RESTORED));
+    rb_define_const(c_domain, "DOMAIN_RUNNING_FROM_SNAPSHOT",
+                    INT2NUM(VIR_DOMAIN_RUNNING_FROM_SNAPSHOT));
+    rb_define_const(c_domain, "DOMAIN_RUNNING_UNPAUSED",
+                    INT2NUM(VIR_DOMAIN_RUNNING_UNPAUSED));
+    rb_define_const(c_domain, "DOMAIN_RUNNING_MIGRATION_CANCELED",
+                    INT2NUM(VIR_DOMAIN_RUNNING_MIGRATION_CANCELED));
+    rb_define_const(c_domain, "DOMAIN_RUNNING_SAVE_CANCELED",
+                    INT2NUM(VIR_DOMAIN_RUNNING_SAVE_CANCELED));
+    rb_define_const(c_domain, "DOMAIN_BLOCKED_UNKNOWN",
+                    INT2NUM(VIR_DOMAIN_BLOCKED_UNKNOWN));
+    rb_define_const(c_domain, "DOMAIN_PAUSED_UNKNOWN",
+                    INT2NUM(VIR_DOMAIN_PAUSED_UNKNOWN));
+    rb_define_const(c_domain, "DOMAIN_PAUSED_USER",
+                    INT2NUM(VIR_DOMAIN_PAUSED_USER));
+    rb_define_const(c_domain, "DOMAIN_PAUSED_MIGRATION",
+                    INT2NUM(VIR_DOMAIN_PAUSED_MIGRATION));
+    rb_define_const(c_domain, "DOMAIN_PAUSED_SAVE",
+                    INT2NUM(VIR_DOMAIN_PAUSED_SAVE));
+    rb_define_const(c_domain, "DOMAIN_PAUSED_DUMP",
+                    INT2NUM(VIR_DOMAIN_PAUSED_DUMP));
+    rb_define_const(c_domain, "DOMAIN_PAUSED_IOERROR",
+                    INT2NUM(VIR_DOMAIN_PAUSED_IOERROR));
+    rb_define_const(c_domain, "DOMAIN_PAUSED_WATCHDOG",
+                    INT2NUM(VIR_DOMAIN_PAUSED_WATCHDOG));
+    rb_define_const(c_domain, "DOMAIN_PAUSED_FROM_SNAPSHOT",
+                    INT2NUM(VIR_DOMAIN_PAUSED_FROM_SNAPSHOT));
+    rb_define_const(c_domain, "DOMAIN_SHUTDOWN_UNKNOWN",
+                    INT2NUM(VIR_DOMAIN_SHUTDOWN_UNKNOWN));
+    rb_define_const(c_domain, "DOMAIN_SHUTDOWN_USER",
+                    INT2NUM(VIR_DOMAIN_SHUTDOWN_USER));
+    rb_define_const(c_domain, "DOMAIN_SHUTOFF_UNKNOWN",
+                    INT2NUM(VIR_DOMAIN_SHUTOFF_UNKNOWN));
+    rb_define_const(c_domain, "DOMAIN_SHUTOFF_SHUTDOWN",
+                    INT2NUM(VIR_DOMAIN_SHUTOFF_SHUTDOWN));
+    rb_define_const(c_domain, "DOMAIN_SHUTOFF_DESTROYED",
+                    INT2NUM(VIR_DOMAIN_SHUTOFF_DESTROYED));
+    rb_define_const(c_domain, "DOMAIN_SHUTOFF_CRASHED",
+                    INT2NUM(VIR_DOMAIN_SHUTOFF_CRASHED));
+    rb_define_const(c_domain, "DOMAIN_SHUTOFF_MIGRATED",
+                    INT2NUM(VIR_DOMAIN_SHUTOFF_MIGRATED));
+    rb_define_const(c_domain, "DOMAIN_SHUTOFF_SAVED",
+                    INT2NUM(VIR_DOMAIN_SHUTOFF_SAVED));
+    rb_define_const(c_domain, "DOMAIN_SHUTOFF_FAILED",
+                    INT2NUM(VIR_DOMAIN_SHUTOFF_FAILED));
+    rb_define_const(c_domain, "DOMAIN_SHUTOFF_FROM_SNAPSHOT",
+                    INT2NUM(VIR_DOMAIN_SHUTOFF_FROM_SNAPSHOT));
+    rb_define_const(c_domain, "DOMAIN_CRASHED_UNKNOWN",
+                    INT2NUM(VIR_DOMAIN_CRASHED_UNKNOWN));
+
+    rb_define_method(c_domain, "state", libvirt_dom_get_state, -1);
+#endif
+
+#if HAVE_CONST_VIR_DOMAIN_AFFECT_CURRENT
+    rb_define_const(c_domain, "DOMAIN_AFFECT_CURRENT",
+                    INT2NUM(VIR_DOMAIN_AFFECT_CURRENT));
+    rb_define_const(c_domain, "DOMAIN_AFFECT_LIVE",
+                    INT2NUM(VIR_DOMAIN_AFFECT_LIVE));
+    rb_define_const(c_domain, "DOMAIN_AFFECT_CONFIG",
+                    INT2NUM(VIR_DOMAIN_AFFECT_CONFIG));
+#endif
+
+#if HAVE_VIRDOMAINOPENCONSOLE
+    rb_define_method(c_domain, "open_console", libvirt_dom_open_console, -1);
+#endif
+
+#if HAVE_VIRDOMAINSCREENSHOT
+    rb_define_method(c_domain, "screenshot", libvirt_dom_screenshot, -1);
+#endif
+
+#if HAVE_VIRDOMAININJECTNMI
+    rb_define_method(c_domain, "inject_nmi", libvirt_dom_inject_nmi, -1);
+#endif
 }