X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=ruby%2Fext%2Fguestfs%2F_guestfs.c;h=4983932f98d3dc7c664c9e5d0d2eb7bba5f98209;hp=0429ae603346293cb99d33f4084649f8de1905f4;hb=d1a1ab972bb22f4c38a21fcc73f81650aaa03b4e;hpb=aed0fa2c015e56a882fd6d4b759c82df08fc40d7

diff --git a/ruby/ext/guestfs/_guestfs.c b/ruby/ext/guestfs/_guestfs.c
index 0429ae6..4983932 100644
--- a/ruby/ext/guestfs/_guestfs.c
+++ b/ruby/ext/guestfs/_guestfs.c
@@ -28,6 +28,11 @@
 
 #include "extconf.h"
 
+/* For Ruby < 1.9 */
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(r) (RARRAY((r))->len)
+#endif
+
 static VALUE m_guestfs;			/* guestfs module */
 static VALUE c_guestfs;			/* guestfs_h handle */
 static VALUE e_Error;			/* used for all errors */
@@ -66,2067 +71,3610 @@ static VALUE ruby_guestfs_close (VALUE gv)
   return Qnil;
 }
 
-static VALUE ruby_guestfs_launch (VALUE gv)
+static VALUE ruby_guestfs_test0 (VALUE gv, VALUE strv, VALUE optstrv, VALUE strlistv, VALUE bv, VALUE integerv, VALUE fileinv, VALUE fileoutv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0");
 
+  const char *str = StringValueCStr (strv);
+  if (!str)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "str", "test0");
+  const char *optstr = !NIL_P (optstrv) ? StringValueCStr (optstrv) : NULL;
+  char **strlist;  {
+    int i, len;
+    len = RARRAY_LEN (strlistv);
+    strlist = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
+    for (i = 0; i < len; ++i) {
+      VALUE v = rb_ary_entry (strlistv, i);
+      strlist[i] = StringValueCStr (v);
+    }
+    strlist[len] = NULL;
+  }
+  int b = RTEST (bv);
+  int integer = NUM2INT (integerv);
+  const char *filein = StringValueCStr (fileinv);
+  if (!filein)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "filein", "test0");
+  const char *fileout = StringValueCStr (fileoutv);
+  if (!fileout)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "fileout", "test0");
 
   int r;
 
-  r = guestfs_launch (g);
+  r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
+  free (strlist);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_wait_ready (VALUE gv)
+static VALUE ruby_guestfs_test0rint (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint");
 
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rint");
 
   int r;
 
-  r = guestfs_wait_ready (g);
+  r = guestfs_test0rint (g, val);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return INT2NUM (r);
 }
 
-static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
+static VALUE ruby_guestfs_test0rinterr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rinterr");
 
 
   int r;
 
-  r = guestfs_kill_subprocess (g);
+  r = guestfs_test0rinterr (g);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return INT2NUM (r);
 }
 
-static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
+static VALUE ruby_guestfs_test0rint64 (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64");
 
-  const char *filename = StringValueCStr (filenamev);
-  if (!filename)
+  const char *val = StringValueCStr (valv);
+  if (!val)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "filename", "add_drive");
+              "val", "test0rint64");
 
-  int r;
+  int64_t r;
 
-  r = guestfs_add_drive (g, filename);
+  r = guestfs_test0rint64 (g, val);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return ULL2NUM (r);
 }
 
-static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
+static VALUE ruby_guestfs_test0rint64err (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64err");
 
-  const char *filename = StringValueCStr (filenamev);
-  if (!filename)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "filename", "add_cdrom");
 
-  int r;
+  int64_t r;
 
-  r = guestfs_add_cdrom (g, filename);
+  r = guestfs_test0rint64err (g);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return ULL2NUM (r);
 }
 
-static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
+static VALUE ruby_guestfs_test0rbool (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rbool");
 
-  const char *qemuparam = StringValueCStr (qemuparamv);
-  if (!qemuparam)
+  const char *val = StringValueCStr (valv);
+  if (!val)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "qemuparam", "config");
-  const char *qemuvalue = StringValueCStr (qemuvaluev);
+              "val", "test0rbool");
 
   int r;
 
-  r = guestfs_config (g, qemuparam, qemuvalue);
+  r = guestfs_test0rbool (g, val);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return INT2NUM (r);
 }
 
-static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
+static VALUE ruby_guestfs_test0rboolerr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rboolerr");
 
-  const char *qemu = StringValueCStr (qemuv);
-  if (!qemu)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "qemu", "set_qemu");
 
   int r;
 
-  r = guestfs_set_qemu (g, qemu);
+  r = guestfs_test0rboolerr (g);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return INT2NUM (r);
 }
 
-static VALUE ruby_guestfs_get_qemu (VALUE gv)
+static VALUE ruby_guestfs_test0rconststring (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststring");
 
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rconststring");
 
   const char *r;
 
-  r = guestfs_get_qemu (g);
+  r = guestfs_test0rconststring (g, val);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return rb_str_new2 (r);
 }
 
-static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_test0rconststringerr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststringerr");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "set_path");
 
-  int r;
+  const char *r;
 
-  r = guestfs_set_path (g, path);
-  if (r == -1)
+  r = guestfs_test0rconststringerr (g);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return rb_str_new2 (r);
 }
 
-static VALUE ruby_guestfs_get_path (VALUE gv)
+static VALUE ruby_guestfs_test0rstring (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstring");
 
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rstring");
 
-  const char *r;
+  char *r;
 
-  r = guestfs_get_path (g);
+  r = guestfs_test0rstring (g, val);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return rb_str_new2 (r);
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
+static VALUE ruby_guestfs_test0rstringerr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringerr");
 
-  int autosync = NUM2INT (autosyncv);
 
-  int r;
+  char *r;
 
-  r = guestfs_set_autosync (g, autosync);
-  if (r == -1)
+  r = guestfs_test0rstringerr (g);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_get_autosync (VALUE gv)
+static VALUE ruby_guestfs_test0rstringlist (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlist");
 
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rstringlist");
 
-  int r;
+  char **r;
 
-  r = guestfs_get_autosync (g);
-  if (r == -1)
+  r = guestfs_test0rstringlist (g, val);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
+static VALUE ruby_guestfs_test0rstringlisterr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlisterr");
 
-  int verbose = NUM2INT (verbosev);
 
-  int r;
+  char **r;
 
-  r = guestfs_set_verbose (g, verbose);
-  if (r == -1)
+  r = guestfs_test0rstringlisterr (g);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_get_verbose (VALUE gv)
+static VALUE ruby_guestfs_test0rintbool (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintbool");
 
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rintbool");
 
-  int r;
+  struct guestfs_int_bool *r;
 
-  r = guestfs_get_verbose (g);
-  if (r == -1)
+  r = guestfs_test0rintbool (g, val);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  VALUE rv = rb_ary_new2 (2);
+  rb_ary_push (rv, INT2NUM (r->i));
+  rb_ary_push (rv, INT2NUM (r->b));
+  guestfs_free_int_bool (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_is_ready (VALUE gv)
+static VALUE ruby_guestfs_test0rintboolerr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintboolerr");
 
 
-  int r;
+  struct guestfs_int_bool *r;
 
-  r = guestfs_is_ready (g);
-  if (r == -1)
+  r = guestfs_test0rintboolerr (g);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  VALUE rv = rb_ary_new2 (2);
+  rb_ary_push (rv, INT2NUM (r->i));
+  rb_ary_push (rv, INT2NUM (r->b));
+  guestfs_free_int_bool (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_is_config (VALUE gv)
+static VALUE ruby_guestfs_test0rpvlist (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlist");
 
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rpvlist");
 
-  int r;
+  struct guestfs_lvm_pv_list *r;
 
-  r = guestfs_is_config (g);
-  if (r == -1)
+  r = guestfs_test0rpvlist (g, val);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  VALUE rv = rb_ary_new2 (r->len);
+  int i;
+  for (i = 0; i < r->len; ++i) {
+    VALUE hv = rb_hash_new ();
+    rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
+    rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
+    rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
+    rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
+    rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
+    rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
+    rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
+    rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
+    rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
+    rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
+    rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
+    rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
+    rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
+    rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
+    rb_ary_push (rv, hv);
+  }
+  guestfs_free_lvm_pv_list (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_is_launching (VALUE gv)
+static VALUE ruby_guestfs_test0rpvlisterr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlisterr");
 
 
-  int r;
+  struct guestfs_lvm_pv_list *r;
 
-  r = guestfs_is_launching (g);
-  if (r == -1)
+  r = guestfs_test0rpvlisterr (g);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  VALUE rv = rb_ary_new2 (r->len);
+  int i;
+  for (i = 0; i < r->len; ++i) {
+    VALUE hv = rb_hash_new ();
+    rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
+    rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
+    rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
+    rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
+    rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
+    rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
+    rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
+    rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
+    rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
+    rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
+    rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
+    rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
+    rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
+    rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
+    rb_ary_push (rv, hv);
+  }
+  guestfs_free_lvm_pv_list (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_is_busy (VALUE gv)
+static VALUE ruby_guestfs_test0rvglist (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglist");
 
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rvglist");
 
-  int r;
+  struct guestfs_lvm_vg_list *r;
 
-  r = guestfs_is_busy (g);
-  if (r == -1)
+  r = guestfs_test0rvglist (g, val);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
-}
-
-static VALUE ruby_guestfs_get_state (VALUE gv)
-{
-  guestfs_h *g;
-  Data_Get_Struct (gv, guestfs_h, g);
-  if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
-
-
-  int r;
-
-  r = guestfs_get_state (g);
-  if (r == -1)
-    rb_raise (e_Error, "%s", guestfs_last_error (g));
-
-  return INT2NUM (r);
+  VALUE rv = rb_ary_new2 (r->len);
+  int i;
+  for (i = 0; i < r->len; ++i) {
+    VALUE hv = rb_hash_new ();
+    rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
+    rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
+    rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
+    rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
+    rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
+    rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
+    rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
+    rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
+    rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
+    rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
+    rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
+    rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
+    rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
+    rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
+    rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
+    rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
+    rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
+    rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
+    rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
+    rb_ary_push (rv, hv);
+  }
+  guestfs_free_lvm_vg_list (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_set_busy (VALUE gv)
+static VALUE ruby_guestfs_test0rvglisterr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglisterr");
 
 
-  int r;
+  struct guestfs_lvm_vg_list *r;
 
-  r = guestfs_set_busy (g);
-  if (r == -1)
+  r = guestfs_test0rvglisterr (g);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_ary_new2 (r->len);
+  int i;
+  for (i = 0; i < r->len; ++i) {
+    VALUE hv = rb_hash_new ();
+    rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
+    rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
+    rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
+    rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
+    rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
+    rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
+    rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
+    rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
+    rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
+    rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
+    rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
+    rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
+    rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
+    rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
+    rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
+    rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
+    rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
+    rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
+    rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
+    rb_ary_push (rv, hv);
+  }
+  guestfs_free_lvm_vg_list (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_set_ready (VALUE gv)
+static VALUE ruby_guestfs_test0rlvlist (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlist");
 
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rlvlist");
 
-  int r;
+  struct guestfs_lvm_lv_list *r;
 
-  r = guestfs_set_ready (g);
-  if (r == -1)
+  r = guestfs_test0rlvlist (g, val);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_ary_new2 (r->len);
+  int i;
+  for (i = 0; i < r->len; ++i) {
+    VALUE hv = rb_hash_new ();
+    rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
+    rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
+    rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
+    rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
+    rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
+    rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
+    rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
+    rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
+    rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
+    rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
+    rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
+    rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
+    rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
+    rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
+    rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
+    rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
+    rb_ary_push (rv, hv);
+  }
+  guestfs_free_lvm_lv_list (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
+static VALUE ruby_guestfs_test0rlvlisterr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlisterr");
 
-  const char *device = StringValueCStr (devicev);
-  if (!device)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "mount");
-  const char *mountpoint = StringValueCStr (mountpointv);
-  if (!mountpoint)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "mountpoint", "mount");
 
-  int r;
+  struct guestfs_lvm_lv_list *r;
 
-  r = guestfs_mount (g, device, mountpoint);
-  if (r == -1)
+  r = guestfs_test0rlvlisterr (g);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_ary_new2 (r->len);
+  int i;
+  for (i = 0; i < r->len; ++i) {
+    VALUE hv = rb_hash_new ();
+    rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
+    rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
+    rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
+    rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
+    rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
+    rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
+    rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
+    rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
+    rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
+    rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
+    rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
+    rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
+    rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
+    rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
+    rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
+    rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
+    rb_ary_push (rv, hv);
+  }
+  guestfs_free_lvm_lv_list (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_sync (VALUE gv)
+static VALUE ruby_guestfs_test0rstat (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstat");
 
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rstat");
 
-  int r;
+  struct guestfs_stat *r;
 
-  r = guestfs_sync (g);
-  if (r == -1)
+  r = guestfs_test0rstat (g, val);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_hash_new ();
+  rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
+  rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
+  rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
+  rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
+  rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
+  rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
+  rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
+  rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
+  rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
+  rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
+  rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
+  rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
+  rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_test0rstaterr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstaterr");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "touch");
 
-  int r;
+  struct guestfs_stat *r;
 
-  r = guestfs_touch (g, path);
-  if (r == -1)
+  r = guestfs_test0rstaterr (g);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_hash_new ();
+  rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
+  rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
+  rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
+  rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
+  rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
+  rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
+  rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
+  rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
+  rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
+  rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
+  rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
+  rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
+  rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_test0rstatvfs (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfs");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *val = StringValueCStr (valv);
+  if (!val)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "cat");
+              "val", "test0rstatvfs");
 
-  char *r;
+  struct guestfs_statvfs *r;
 
-  r = guestfs_cat (g, path);
+  r = guestfs_test0rstatvfs (g, val);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_str_new2 (r);
+  VALUE rv = rb_hash_new ();
+  rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
+  rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
+  rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
+  rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
+  rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
+  rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
+  rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
+  rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
+  rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
+  rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
+  rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
   free (r);
   return rv;
 }
 
-static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
+static VALUE ruby_guestfs_test0rstatvfserr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfserr");
 
-  const char *directory = StringValueCStr (directoryv);
-  if (!directory)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "directory", "ll");
 
-  char *r;
+  struct guestfs_statvfs *r;
 
-  r = guestfs_ll (g, directory);
+  r = guestfs_test0rstatvfserr (g);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_str_new2 (r);
+  VALUE rv = rb_hash_new ();
+  rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
+  rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
+  rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
+  rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
+  rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
+  rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
+  rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
+  rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
+  rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
+  rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
+  rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
   free (r);
   return rv;
 }
 
-static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
+static VALUE ruby_guestfs_test0rhashtable (VALUE gv, VALUE valv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtable");
 
-  const char *directory = StringValueCStr (directoryv);
-  if (!directory)
+  const char *val = StringValueCStr (valv);
+  if (!val)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "directory", "ls");
+              "val", "test0rhashtable");
 
   char **r;
 
-  r = guestfs_ls (g, directory);
+  r = guestfs_test0rhashtable (g, val);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
+  VALUE rv = rb_hash_new ();
+  int i;
+  for (i = 0; r[i] != NULL; i+=2) {
+    rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
     free (r[i]);
+    free (r[i+1]);
   }
   free (r);
   return rv;
 }
 
-static VALUE ruby_guestfs_list_devices (VALUE gv)
+static VALUE ruby_guestfs_test0rhashtableerr (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtableerr");
 
 
   char **r;
 
-  r = guestfs_list_devices (g);
+  r = guestfs_test0rhashtableerr (g);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
+  VALUE rv = rb_hash_new ();
+  int i;
+  for (i = 0; r[i] != NULL; i+=2) {
+    rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
     free (r[i]);
+    free (r[i+1]);
   }
   free (r);
   return rv;
 }
 
-static VALUE ruby_guestfs_list_partitions (VALUE gv)
+static VALUE ruby_guestfs_launch (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
 
 
-  char **r;
+  int r;
 
-  r = guestfs_list_partitions (g);
-  if (r == NULL)
+  r = guestfs_launch (g);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
-    free (r[i]);
-  }
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_pvs (VALUE gv)
+static VALUE ruby_guestfs_wait_ready (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
 
 
-  char **r;
+  int r;
 
-  r = guestfs_pvs (g);
-  if (r == NULL)
+  r = guestfs_wait_ready (g);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
-    free (r[i]);
-  }
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_vgs (VALUE gv)
+static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
 
 
-  char **r;
+  int r;
 
-  r = guestfs_vgs (g);
-  if (r == NULL)
+  r = guestfs_kill_subprocess (g);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
-    free (r[i]);
-  }
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_lvs (VALUE gv)
+static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
 
+  const char *filename = StringValueCStr (filenamev);
+  if (!filename)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "filename", "add_drive");
 
-  char **r;
+  int r;
 
-  r = guestfs_lvs (g);
-  if (r == NULL)
+  r = guestfs_add_drive (g, filename);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
-    free (r[i]);
-  }
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_pvs_full (VALUE gv)
+static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
 
+  const char *filename = StringValueCStr (filenamev);
+  if (!filename)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "filename", "add_cdrom");
 
-  struct guestfs_lvm_pv_list *r;
+  int r;
 
-  r = guestfs_pvs_full (g);
-  if (r == NULL)
+  r = guestfs_add_cdrom (g, filename);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_ary_new2 (r->len);
-  int i;
-  for (i = 0; i < r->len; ++i) {
-    VALUE hv = rb_hash_new ();
-    rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
-    rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
-    rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
-    rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
-    rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
-    rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
-    rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
-    rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
-    rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
-    rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
-    rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
-    rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
-    rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
-    rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
-    rb_ary_push (rv, hv);
-  }
-  guestfs_free_lvm_pv_list (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_vgs_full (VALUE gv)
+static VALUE ruby_guestfs_add_drive_ro (VALUE gv, VALUE filenamev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive_ro");
 
+  const char *filename = StringValueCStr (filenamev);
+  if (!filename)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "filename", "add_drive_ro");
 
-  struct guestfs_lvm_vg_list *r;
+  int r;
 
-  r = guestfs_vgs_full (g);
-  if (r == NULL)
+  r = guestfs_add_drive_ro (g, filename);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_ary_new2 (r->len);
-  int i;
-  for (i = 0; i < r->len; ++i) {
-    VALUE hv = rb_hash_new ();
-    rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
-    rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
-    rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
-    rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
-    rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
-    rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
-    rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
-    rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
-    rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
-    rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
-    rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
-    rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
-    rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
-    rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
-    rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
-    rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
-    rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
-    rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
-    rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
-    rb_ary_push (rv, hv);
-  }
-  guestfs_free_lvm_vg_list (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_lvs_full (VALUE gv)
+static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
 
+  const char *qemuparam = StringValueCStr (qemuparamv);
+  if (!qemuparam)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "qemuparam", "config");
+  const char *qemuvalue = !NIL_P (qemuvaluev) ? StringValueCStr (qemuvaluev) : NULL;
 
-  struct guestfs_lvm_lv_list *r;
+  int r;
 
-  r = guestfs_lvs_full (g);
+  r = guestfs_config (g, qemuparam, qemuvalue);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
+
+  const char *qemu = StringValueCStr (qemuv);
+  if (!qemu)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "qemu", "set_qemu");
+
+  int r;
+
+  r = guestfs_set_qemu (g, qemu);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_get_qemu (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
+
+
+  const char *r;
+
+  r = guestfs_get_qemu (g);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_ary_new2 (r->len);
-  int i;
-  for (i = 0; i < r->len; ++i) {
-    VALUE hv = rb_hash_new ();
-    rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
-    rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
-    rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
-    rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
-    rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
-    rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
-    rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
-    rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
-    rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
-    rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
-    rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
-    rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
-    rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
-    rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
-    rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
-    rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
-    rb_ary_push (rv, hv);
-  }
-  guestfs_free_lvm_lv_list (r);
-  return rv;
+  return rb_str_new2 (r);
+}
+
+static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "set_path");
+
+  int r;
+
+  r = guestfs_set_path (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_get_path (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
+
+
+  const char *r;
+
+  r = guestfs_get_path (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return rb_str_new2 (r);
+}
+
+static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_append");
+
+  const char *append = StringValueCStr (appendv);
+  if (!append)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "append", "set_append");
+
+  int r;
+
+  r = guestfs_set_append (g, append);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_get_append (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append");
+
+
+  const char *r;
+
+  r = guestfs_get_append (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return rb_str_new2 (r);
+}
+
+static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
+
+  int autosync = RTEST (autosyncv);
+
+  int r;
+
+  r = guestfs_set_autosync (g, autosync);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_get_autosync (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
+
+
+  int r;
+
+  r = guestfs_get_autosync (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
+
+  int verbose = RTEST (verbosev);
+
+  int r;
+
+  r = guestfs_set_verbose (g, verbose);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_get_verbose (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
+
+
+  int r;
+
+  r = guestfs_get_verbose (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_is_ready (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
+
+
+  int r;
+
+  r = guestfs_is_ready (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_is_config (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
+
+
+  int r;
+
+  r = guestfs_is_config (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_is_launching (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
+
+
+  int r;
+
+  r = guestfs_is_launching (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_is_busy (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
+
+
+  int r;
+
+  r = guestfs_is_busy (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_get_state (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
+
+
+  int r;
+
+  r = guestfs_get_state (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_set_busy (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
+
+
+  int r;
+
+  r = guestfs_set_busy (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_set_ready (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
+
+
+  int r;
+
+  r = guestfs_set_ready (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_end_busy (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
+
+
+  int r;
+
+  r = guestfs_end_busy (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
+
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "mount");
+  const char *mountpoint = StringValueCStr (mountpointv);
+  if (!mountpoint)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "mountpoint", "mount");
+
+  int r;
+
+  r = guestfs_mount (g, device, mountpoint);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_sync (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
+
+
+  int r;
+
+  r = guestfs_sync (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "touch");
+
+  int r;
+
+  r = guestfs_touch (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "cat");
+
+  char *r;
+
+  r = guestfs_cat (g, path);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
+
+  const char *directory = StringValueCStr (directoryv);
+  if (!directory)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "directory", "ll");
+
+  char *r;
+
+  r = guestfs_ll (g, directory);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
+
+  const char *directory = StringValueCStr (directoryv);
+  if (!directory)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "directory", "ls");
+
+  char **r;
+
+  r = guestfs_ls (g, directory);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_list_devices (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
+
+
+  char **r;
+
+  r = guestfs_list_devices (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_list_partitions (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
+
+
+  char **r;
+
+  r = guestfs_list_partitions (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_pvs (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
+
+
+  char **r;
+
+  r = guestfs_pvs (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_vgs (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
+
+
+  char **r;
+
+  r = guestfs_vgs (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_lvs (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
+
+
+  char **r;
+
+  r = guestfs_lvs (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_pvs_full (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
+
+
+  struct guestfs_lvm_pv_list *r;
+
+  r = guestfs_pvs_full (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  VALUE rv = rb_ary_new2 (r->len);
+  int i;
+  for (i = 0; i < r->len; ++i) {
+    VALUE hv = rb_hash_new ();
+    rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
+    rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
+    rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
+    rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
+    rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
+    rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
+    rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
+    rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
+    rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
+    rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
+    rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
+    rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
+    rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
+    rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
+    rb_ary_push (rv, hv);
+  }
+  guestfs_free_lvm_pv_list (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_vgs_full (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
+
+
+  struct guestfs_lvm_vg_list *r;
+
+  r = guestfs_vgs_full (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  VALUE rv = rb_ary_new2 (r->len);
+  int i;
+  for (i = 0; i < r->len; ++i) {
+    VALUE hv = rb_hash_new ();
+    rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
+    rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
+    rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
+    rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
+    rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
+    rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
+    rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
+    rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
+    rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
+    rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
+    rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
+    rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
+    rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
+    rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
+    rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
+    rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
+    rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
+    rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
+    rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
+    rb_ary_push (rv, hv);
+  }
+  guestfs_free_lvm_vg_list (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_lvs_full (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
+
+
+  struct guestfs_lvm_lv_list *r;
+
+  r = guestfs_lvs_full (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  VALUE rv = rb_ary_new2 (r->len);
+  int i;
+  for (i = 0; i < r->len; ++i) {
+    VALUE hv = rb_hash_new ();
+    rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
+    rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
+    rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
+    rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
+    rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
+    rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
+    rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
+    rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
+    rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
+    rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
+    rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
+    rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
+    rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
+    rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
+    rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
+    rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
+    rb_ary_push (rv, hv);
+  }
+  guestfs_free_lvm_lv_list (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "read_lines");
+
+  char **r;
+
+  r = guestfs_read_lines (g, path);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
+
+  const char *root = StringValueCStr (rootv);
+  if (!root)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "root", "aug_init");
+  int flags = NUM2INT (flagsv);
+
+  int r;
+
+  r = guestfs_aug_init (g, root, flags);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_aug_close (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
+
+
+  int r;
+
+  r = guestfs_aug_close (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
+
+  const char *name = StringValueCStr (namev);
+  if (!name)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "name", "aug_defvar");
+  const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL;
+
+  int r;
+
+  r = guestfs_aug_defvar (g, name, expr);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
+
+  const char *name = StringValueCStr (namev);
+  if (!name)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "name", "aug_defnode");
+  const char *expr = StringValueCStr (exprv);
+  if (!expr)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "expr", "aug_defnode");
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "aug_defnode");
+
+  struct guestfs_int_bool *r;
+
+  r = guestfs_aug_defnode (g, name, expr, val);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  VALUE rv = rb_ary_new2 (2);
+  rb_ary_push (rv, INT2NUM (r->i));
+  rb_ary_push (rv, INT2NUM (r->b));
+  guestfs_free_int_bool (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "aug_get");
+
+  char *r;
+
+  r = guestfs_aug_get (g, path);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "aug_set");
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "aug_set");
+
+  int r;
+
+  r = guestfs_aug_set (g, path, val);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "aug_insert");
+  const char *label = StringValueCStr (labelv);
+  if (!label)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "label", "aug_insert");
+  int before = RTEST (beforev);
+
+  int r;
+
+  r = guestfs_aug_insert (g, path, label, before);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "aug_rm");
+
+  int r;
+
+  r = guestfs_aug_rm (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
+
+  const char *src = StringValueCStr (srcv);
+  if (!src)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "src", "aug_mv");
+  const char *dest = StringValueCStr (destv);
+  if (!dest)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "dest", "aug_mv");
+
+  int r;
+
+  r = guestfs_aug_mv (g, src, dest);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "aug_match");
+
+  char **r;
+
+  r = guestfs_aug_match (g, path);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_aug_save (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
+
+
+  int r;
+
+  r = guestfs_aug_save (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_aug_load (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
+
+
+  int r;
+
+  r = guestfs_aug_load (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "aug_ls");
+
+  char **r;
+
+  r = guestfs_aug_ls (g, path);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "rm");
+
+  int r;
+
+  r = guestfs_rm (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "rmdir");
+
+  int r;
+
+  r = guestfs_rmdir (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "rm_rf");
+
+  int r;
+
+  r = guestfs_rm_rf (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "mkdir");
+
+  int r;
+
+  r = guestfs_mkdir (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "mkdir_p");
+
+  int r;
+
+  r = guestfs_mkdir_p (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
+
+  int mode = NUM2INT (modev);
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "chmod");
+
+  int r;
+
+  r = guestfs_chmod (g, mode, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
+
+  int owner = NUM2INT (ownerv);
+  int group = NUM2INT (groupv);
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "chown");
+
+  int r;
+
+  r = guestfs_chown (g, owner, group, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "exists");
+
+  int r;
+
+  r = guestfs_exists (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "is_file");
+
+  int r;
+
+  r = guestfs_is_file (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "is_dir");
+
+  int r;
+
+  r = guestfs_is_dir (g, path);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
+
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "pvcreate");
+
+  int r;
+
+  r = guestfs_pvcreate (g, device);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
+
+  const char *volgroup = StringValueCStr (volgroupv);
+  if (!volgroup)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "volgroup", "vgcreate");
+  char **physvols;  {
+    int i, len;
+    len = RARRAY_LEN (physvolsv);
+    physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
+    for (i = 0; i < len; ++i) {
+      VALUE v = rb_ary_entry (physvolsv, i);
+      physvols[i] = StringValueCStr (v);
+    }
+    physvols[len] = NULL;
+  }
+
+  int r;
+
+  r = guestfs_vgcreate (g, volgroup, physvols);
+  free (physvols);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
+
+  const char *logvol = StringValueCStr (logvolv);
+  if (!logvol)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "logvol", "lvcreate");
+  const char *volgroup = StringValueCStr (volgroupv);
+  if (!volgroup)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "volgroup", "lvcreate");
+  int mbytes = NUM2INT (mbytesv);
+
+  int r;
+
+  r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *fstype = StringValueCStr (fstypev);
+  if (!fstype)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "read_lines");
+              "fstype", "mkfs");
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "mkfs");
 
-  char **r;
+  int r;
 
-  r = guestfs_read_lines (g, path);
-  if (r == NULL)
+  r = guestfs_mkfs (g, fstype, device);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
-    free (r[i]);
-  }
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
+static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
 
-  const char *root = StringValueCStr (rootv);
-  if (!root)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "root", "aug_init");
-  int flags = NUM2INT (flagsv);
+              "device", "sfdisk");
+  int cyls = NUM2INT (cylsv);
+  int heads = NUM2INT (headsv);
+  int sectors = NUM2INT (sectorsv);
+  char **lines;  {
+    int i, len;
+    len = RARRAY_LEN (linesv);
+    lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
+    for (i = 0; i < len; ++i) {
+      VALUE v = rb_ary_entry (linesv, i);
+      lines[i] = StringValueCStr (v);
+    }
+    lines[len] = NULL;
+  }
 
   int r;
 
-  r = guestfs_aug_init (g, root, flags);
+  r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
+  free (lines);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_aug_close (VALUE gv)
+static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
 
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "write_file");
+  const char *content = StringValueCStr (contentv);
+  if (!content)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "content", "write_file");
+  int size = NUM2INT (sizev);
 
   int r;
 
-  r = guestfs_aug_close (g);
+  r = guestfs_write_file (g, path, content, size);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
+static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
 
-  const char *name = StringValueCStr (namev);
-  if (!name)
+  const char *pathordevice = StringValueCStr (pathordevicev);
+  if (!pathordevice)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "name", "aug_defvar");
-  const char *expr = StringValueCStr (exprv);
+              "pathordevice", "umount");
 
   int r;
 
-  r = guestfs_aug_defvar (g, name, expr);
+  r = guestfs_umount (g, pathordevice);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
+static VALUE ruby_guestfs_mounts (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
 
-  const char *name = StringValueCStr (namev);
-  if (!name)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "name", "aug_defnode");
-  const char *expr = StringValueCStr (exprv);
-  if (!expr)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "expr", "aug_defnode");
-  const char *val = StringValueCStr (valv);
-  if (!val)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "val", "aug_defnode");
 
-  struct guestfs_int_bool *r;
+  char **r;
 
-  r = guestfs_aug_defnode (g, name, expr, val);
+  r = guestfs_mounts (g);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_ary_new2 (2);
-  rb_ary_push (rv, INT2NUM (r->i));
-  rb_ary_push (rv, INT2NUM (r->b));
-  guestfs_free_int_bool (r);
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
   return rv;
 }
 
-static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_umount_all (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "aug_get");
 
-  char *r;
+  int r;
 
-  r = guestfs_aug_get (g, path);
-  if (r == NULL)
+  r = guestfs_umount_all (g);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_str_new2 (r);
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
+static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "aug_set");
-  const char *val = StringValueCStr (valv);
-  if (!val)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "val", "aug_set");
 
   int r;
 
-  r = guestfs_aug_set (g, path, val);
+  r = guestfs_lvm_remove_all (g);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
+static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
 
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "aug_insert");
-  const char *label = StringValueCStr (labelv);
-  if (!label)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "label", "aug_insert");
-  int before = NUM2INT (beforev);
+              "path", "file");
 
-  int r;
+  char *r;
 
-  r = guestfs_aug_insert (g, path, label, before);
-  if (r == -1)
+  r = guestfs_file (g, path);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "aug_rm");
+  char **arguments;  {
+    int i, len;
+    len = RARRAY_LEN (argumentsv);
+    arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
+    for (i = 0; i < len; ++i) {
+      VALUE v = rb_ary_entry (argumentsv, i);
+      arguments[i] = StringValueCStr (v);
+    }
+    arguments[len] = NULL;
+  }
 
-  int r;
+  char *r;
 
-  r = guestfs_aug_rm (g, path);
-  if (r == -1)
+  r = guestfs_command (g, arguments);
+  free (arguments);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
+static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
 
-  const char *src = StringValueCStr (srcv);
-  if (!src)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "src", "aug_mv");
-  const char *dest = StringValueCStr (destv);
-  if (!dest)
+  char **arguments;  {
+    int i, len;
+    len = RARRAY_LEN (argumentsv);
+    arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
+    for (i = 0; i < len; ++i) {
+      VALUE v = rb_ary_entry (argumentsv, i);
+      arguments[i] = StringValueCStr (v);
+    }
+    arguments[len] = NULL;
+  }
+
+  char **r;
+
+  r = guestfs_command_lines (g, arguments);
+  free (arguments);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
+
+  const char *path = StringValueCStr (pathv);
+  if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "dest", "aug_mv");
+              "path", "stat");
 
-  int r;
+  struct guestfs_stat *r;
 
-  r = guestfs_aug_mv (g, src, dest);
-  if (r == -1)
+  r = guestfs_stat (g, path);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_hash_new ();
+  rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
+  rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
+  rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
+  rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
+  rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
+  rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
+  rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
+  rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
+  rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
+  rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
+  rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
+  rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
+  rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
 
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "aug_match");
+              "path", "lstat");
 
-  char **r;
+  struct guestfs_stat *r;
 
-  r = guestfs_aug_match (g, path);
+  r = guestfs_lstat (g, path);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
-    free (r[i]);
-  }
+  VALUE rv = rb_hash_new ();
+  rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
+  rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
+  rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
+  rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
+  rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
+  rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
+  rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
+  rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
+  rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
+  rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
+  rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
+  rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
+  rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
   free (r);
   return rv;
 }
 
-static VALUE ruby_guestfs_aug_save (VALUE gv)
+static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
 
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "statvfs");
 
-  int r;
+  struct guestfs_statvfs *r;
 
-  r = guestfs_aug_save (g);
-  if (r == -1)
+  r = guestfs_statvfs (g, path);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_hash_new ();
+  rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
+  rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
+  rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
+  rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
+  rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
+  rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
+  rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
+  rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
+  rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
+  rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
+  rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_aug_load (VALUE gv)
+static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
 
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "tune2fs_l");
 
-  int r;
+  char **r;
 
-  r = guestfs_aug_load (g);
-  if (r == -1)
+  r = guestfs_tune2fs_l (g, device);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_hash_new ();
+  int i;
+  for (i = 0; r[i] != NULL; i+=2) {
+    rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
+    free (r[i]);
+    free (r[i+1]);
+  }
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "aug_ls");
+              "device", "blockdev_setro");
 
-  char **r;
+  int r;
 
-  r = guestfs_aug_ls (g, path);
-  if (r == NULL)
+  r = guestfs_blockdev_setro (g, device);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
-    free (r[i]);
-  }
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "rm");
+              "device", "blockdev_setrw");
 
   int r;
 
-  r = guestfs_rm (g, path);
+  r = guestfs_blockdev_setrw (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "rmdir");
+              "device", "blockdev_getro");
 
   int r;
 
-  r = guestfs_rmdir (g, path);
+  r = guestfs_blockdev_getro (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return INT2NUM (r);
 }
 
-static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "rm_rf");
+              "device", "blockdev_getss");
 
   int r;
 
-  r = guestfs_rm_rf (g, path);
+  r = guestfs_blockdev_getss (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return INT2NUM (r);
 }
 
-static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "mkdir");
+              "device", "blockdev_getbsz");
 
   int r;
 
-  r = guestfs_mkdir (g, path);
+  r = guestfs_blockdev_getbsz (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return INT2NUM (r);
 }
 
-static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "mkdir_p");
+              "device", "blockdev_setbsz");
+  int blocksize = NUM2INT (blocksizev);
 
   int r;
 
-  r = guestfs_mkdir_p (g, path);
+  r = guestfs_blockdev_setbsz (g, device, blocksize);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
+static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
 
-  int mode = NUM2INT (modev);
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "chmod");
+              "device", "blockdev_getsz");
 
-  int r;
+  int64_t r;
 
-  r = guestfs_chmod (g, mode, path);
+  r = guestfs_blockdev_getsz (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return ULL2NUM (r);
 }
 
-static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
+static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
 
-  int owner = NUM2INT (ownerv);
-  int group = NUM2INT (groupv);
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "chown");
+              "device", "blockdev_getsize64");
 
-  int r;
+  int64_t r;
 
-  r = guestfs_chown (g, owner, group, path);
+  r = guestfs_blockdev_getsize64 (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return ULL2NUM (r);
 }
 
-static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "exists");
+              "device", "blockdev_flushbufs");
 
   int r;
 
-  r = guestfs_exists (g, path);
+  r = guestfs_blockdev_flushbufs (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "is_file");
+              "device", "blockdev_rereadpt");
 
   int r;
 
-  r = guestfs_is_file (g, path);
+  r = guestfs_blockdev_rereadpt (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *filename = StringValueCStr (filenamev);
+  if (!filename)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "is_dir");
+              "filename", "upload");
+  const char *remotefilename = StringValueCStr (remotefilenamev);
+  if (!remotefilename)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "remotefilename", "upload");
 
   int r;
 
-  r = guestfs_is_dir (g, path);
+  r = guestfs_upload (g, filename, remotefilename);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
 
-  const char *device = StringValueCStr (devicev);
-  if (!device)
+  const char *remotefilename = StringValueCStr (remotefilenamev);
+  if (!remotefilename)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "pvcreate");
+              "remotefilename", "download");
+  const char *filename = StringValueCStr (filenamev);
+  if (!filename)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "filename", "download");
 
   int r;
 
-  r = guestfs_pvcreate (g, device);
+  r = guestfs_download (g, remotefilename, filename);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
+static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
 
-  const char *volgroup = StringValueCStr (volgroupv);
-  if (!volgroup)
+  const char *csumtype = StringValueCStr (csumtypev);
+  if (!csumtype)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "volgroup", "vgcreate");
-  char **physvols;  {
-    int i, len;
-    len = RARRAY_LEN (physvolsv);
-    physvols = malloc (sizeof (char *) * (len+1));
-    for (i = 0; i < len; ++i) {
-      VALUE v = rb_ary_entry (physvolsv, i);
-      physvols[i] = StringValueCStr (v);
-    }
-    physvols[len] = NULL;
-  }
+              "csumtype", "checksum");
+  const char *path = StringValueCStr (pathv);
+  if (!path)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "path", "checksum");
 
-  int r;
+  char *r;
 
-  r = guestfs_vgcreate (g, volgroup, physvols);
-  free (physvols);
-  if (r == -1)
+  r = guestfs_checksum (g, csumtype, path);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
+static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
 
-  const char *logvol = StringValueCStr (logvolv);
-  if (!logvol)
+  const char *tarfile = StringValueCStr (tarfilev);
+  if (!tarfile)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "logvol", "lvcreate");
-  const char *volgroup = StringValueCStr (volgroupv);
-  if (!volgroup)
+              "tarfile", "tar_in");
+  const char *directory = StringValueCStr (directoryv);
+  if (!directory)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "volgroup", "lvcreate");
-  int mbytes = NUM2INT (mbytesv);
+              "directory", "tar_in");
 
   int r;
 
-  r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
+  r = guestfs_tar_in (g, tarfile, directory);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
+static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
 
-  const char *fstype = StringValueCStr (fstypev);
-  if (!fstype)
+  const char *directory = StringValueCStr (directoryv);
+  if (!directory)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "fstype", "mkfs");
-  const char *device = StringValueCStr (devicev);
-  if (!device)
+              "directory", "tar_out");
+  const char *tarfile = StringValueCStr (tarfilev);
+  if (!tarfile)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "mkfs");
+              "tarfile", "tar_out");
 
   int r;
 
-  r = guestfs_mkfs (g, fstype, device);
+  r = guestfs_tar_out (g, directory, tarfile);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
+static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
 
-  const char *device = StringValueCStr (devicev);
-  if (!device)
+  const char *tarball = StringValueCStr (tarballv);
+  if (!tarball)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "sfdisk");
-  int cyls = NUM2INT (cylsv);
-  int heads = NUM2INT (headsv);
-  int sectors = NUM2INT (sectorsv);
-  char **lines;  {
-    int i, len;
-    len = RARRAY_LEN (linesv);
-    lines = malloc (sizeof (char *) * (len+1));
-    for (i = 0; i < len; ++i) {
-      VALUE v = rb_ary_entry (linesv, i);
-      lines[i] = StringValueCStr (v);
-    }
-    lines[len] = NULL;
-  }
+              "tarball", "tgz_in");
+  const char *directory = StringValueCStr (directoryv);
+  if (!directory)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "directory", "tgz_in");
 
   int r;
 
-  r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
-  free (lines);
+  r = guestfs_tgz_in (g, tarball, directory);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
+static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *directory = StringValueCStr (directoryv);
+  if (!directory)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "write_file");
-  const char *content = StringValueCStr (contentv);
-  if (!content)
+              "directory", "tgz_out");
+  const char *tarball = StringValueCStr (tarballv);
+  if (!tarball)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "content", "write_file");
-  int size = NUM2INT (sizev);
+              "tarball", "tgz_out");
 
   int r;
 
-  r = guestfs_write_file (g, path, content, size);
+  r = guestfs_tgz_out (g, directory, tarball);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
+static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
 
-  const char *pathordevice = StringValueCStr (pathordevicev);
-  if (!pathordevice)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "pathordevice", "umount");
+              "device", "mount_ro");
+  const char *mountpoint = StringValueCStr (mountpointv);
+  if (!mountpoint)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "mountpoint", "mount_ro");
 
   int r;
 
-  r = guestfs_umount (g, pathordevice);
+  r = guestfs_mount_ro (g, device, mountpoint);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_mounts (VALUE gv)
+static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
 
+  const char *options = StringValueCStr (optionsv);
+  if (!options)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "options", "mount_options");
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "mount_options");
+  const char *mountpoint = StringValueCStr (mountpointv);
+  if (!mountpoint)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "mountpoint", "mount_options");
 
-  char **r;
+  int r;
 
-  r = guestfs_mounts (g);
-  if (r == NULL)
+  r = guestfs_mount_options (g, options, device, mountpoint);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
-    free (r[i]);
-  }
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_umount_all (VALUE gv)
+static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
 
+  const char *options = StringValueCStr (optionsv);
+  if (!options)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "options", "mount_vfs");
+  const char *vfstype = StringValueCStr (vfstypev);
+  if (!vfstype)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "vfstype", "mount_vfs");
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "mount_vfs");
+  const char *mountpoint = StringValueCStr (mountpointv);
+  if (!mountpoint)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "mountpoint", "mount_vfs");
 
   int r;
 
-  r = guestfs_umount_all (g);
+  r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
+static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
 
+  const char *subcmd = StringValueCStr (subcmdv);
+  if (!subcmd)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "subcmd", "debug");
+  char **extraargs;  {
+    int i, len;
+    len = RARRAY_LEN (extraargsv);
+    extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
+    for (i = 0; i < len; ++i) {
+      VALUE v = rb_ary_entry (extraargsv, i);
+      extraargs[i] = StringValueCStr (v);
+    }
+    extraargs[len] = NULL;
+  }
 
-  int r;
+  char *r;
 
-  r = guestfs_lvm_remove_all (g);
-  if (r == -1)
+  r = guestfs_debug (g, subcmd, extraargs);
+  free (extraargs);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "file");
+              "device", "lvremove");
 
-  char *r;
+  int r;
 
-  r = guestfs_file (g, path);
-  if (r == NULL)
+  r = guestfs_lvremove (g, device);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_str_new2 (r);
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
+static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
 
-  char **arguments;  {
-    int i, len;
-    len = RARRAY_LEN (argumentsv);
-    arguments = malloc (sizeof (char *) * (len+1));
-    for (i = 0; i < len; ++i) {
-      VALUE v = rb_ary_entry (argumentsv, i);
-      arguments[i] = StringValueCStr (v);
-    }
-    arguments[len] = NULL;
-  }
+  const char *vgname = StringValueCStr (vgnamev);
+  if (!vgname)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "vgname", "vgremove");
 
-  char *r;
+  int r;
 
-  r = guestfs_command (g, arguments);
-  free (arguments);
-  if (r == NULL)
+  r = guestfs_vgremove (g, vgname);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_str_new2 (r);
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
+static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
 
-  char **arguments;  {
-    int i, len;
-    len = RARRAY_LEN (argumentsv);
-    arguments = malloc (sizeof (char *) * (len+1));
-    for (i = 0; i < len; ++i) {
-      VALUE v = rb_ary_entry (argumentsv, i);
-      arguments[i] = StringValueCStr (v);
-    }
-    arguments[len] = NULL;
-  }
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "pvremove");
 
-  char **r;
+  int r;
 
-  r = guestfs_command_lines (g, arguments);
-  free (arguments);
-  if (r == NULL)
+  r = guestfs_pvremove (g, device);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  int i, len = 0;
-  for (i = 0; r[i] != NULL; ++i) len++;
-  VALUE rv = rb_ary_new2 (len);
-  for (i = 0; r[i] != NULL; ++i) {
-    rb_ary_push (rv, rb_str_new2 (r[i]));
-    free (r[i]);
-  }
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "stat");
+              "device", "set_e2label");
+  const char *label = StringValueCStr (labelv);
+  if (!label)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "label", "set_e2label");
 
-  struct guestfs_stat *r;
+  int r;
 
-  r = guestfs_stat (g, path);
-  if (r == NULL)
+  r = guestfs_set_e2label (g, device, label);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_hash_new ();
-  rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
-  rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
-  rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
-  rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
-  rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
-  rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
-  rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
-  rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
-  rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
-  rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
-  rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
-  rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
-  rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "lstat");
+              "device", "get_e2label");
 
-  struct guestfs_stat *r;
+  char *r;
 
-  r = guestfs_lstat (g, path);
+  r = guestfs_get_e2label (g, device);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_hash_new ();
-  rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
-  rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
-  rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
-  rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
-  rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
-  rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
-  rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
-  rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
-  rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
-  rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
-  rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
-  rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
-  rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
+  VALUE rv = rb_str_new2 (r);
   free (r);
   return rv;
 }
 
-static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
+static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
 
-  const char *path = StringValueCStr (pathv);
-  if (!path)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "statvfs");
+              "device", "set_e2uuid");
+  const char *uuid = StringValueCStr (uuidv);
+  if (!uuid)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "uuid", "set_e2uuid");
 
-  struct guestfs_statvfs *r;
+  int r;
 
-  r = guestfs_statvfs (g, path);
-  if (r == NULL)
+  r = guestfs_set_e2uuid (g, device, uuid);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_hash_new ();
-  rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
-  rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
-  rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
-  rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
-  rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
-  rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
-  rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
-  rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
-  rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
-  rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
-  rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
 
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "tune2fs_l");
+              "device", "get_e2uuid");
 
-  char **r;
+  char *r;
 
-  r = guestfs_tune2fs_l (g, device);
+  r = guestfs_get_e2uuid (g, device);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_hash_new ();
-  int i;
-  for (i = 0; r[i] != NULL; i+=2) {
-    rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
-    free (r[i]);
-    free (r[i+1]);
-  }
+  VALUE rv = rb_str_new2 (r);
   free (r);
   return rv;
 }
 
-static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
 
+  const char *fstype = StringValueCStr (fstypev);
+  if (!fstype)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "fstype", "fsck");
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "blockdev_setro");
+              "device", "fsck");
 
   int r;
 
-  r = guestfs_blockdev_setro (g, device);
+  r = guestfs_fsck (g, fstype, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return INT2NUM (r);
 }
 
-static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
 
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "blockdev_setrw");
+              "device", "zero");
 
   int r;
 
-  r = guestfs_blockdev_setrw (g, device);
+  r = guestfs_zero (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
 
+  const char *root = StringValueCStr (rootv);
+  if (!root)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "root", "grub_install");
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "blockdev_getro");
+              "device", "grub_install");
 
   int r;
 
-  r = guestfs_blockdev_getro (g, device);
+  r = guestfs_grub_install (g, root, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
 
-  const char *device = StringValueCStr (devicev);
-  if (!device)
+  const char *src = StringValueCStr (srcv);
+  if (!src)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "blockdev_getss");
+              "src", "cp");
+  const char *dest = StringValueCStr (destv);
+  if (!dest)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "dest", "cp");
 
   int r;
 
-  r = guestfs_blockdev_getss (g, device);
+  r = guestfs_cp (g, src, dest);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
 
-  const char *device = StringValueCStr (devicev);
-  if (!device)
+  const char *src = StringValueCStr (srcv);
+  if (!src)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "blockdev_getbsz");
+              "src", "cp_a");
+  const char *dest = StringValueCStr (destv);
+  if (!dest)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "dest", "cp_a");
 
   int r;
 
-  r = guestfs_blockdev_getbsz (g, device);
+  r = guestfs_cp_a (g, src, dest);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return INT2NUM (r);
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
+static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
 
-  const char *device = StringValueCStr (devicev);
-  if (!device)
+  const char *src = StringValueCStr (srcv);
+  if (!src)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "blockdev_setbsz");
-  int blocksize = NUM2INT (blocksizev);
+              "src", "mv");
+  const char *dest = StringValueCStr (destv);
+  if (!dest)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "dest", "mv");
 
   int r;
 
-  r = guestfs_blockdev_setbsz (g, device, blocksize);
+  r = guestfs_mv (g, src, dest);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
 
-  const char *device = StringValueCStr (devicev);
-  if (!device)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "blockdev_getsz");
+  int whattodrop = NUM2INT (whattodropv);
 
-  int64_t r;
+  int r;
 
-  r = guestfs_blockdev_getsz (g, device);
+  r = guestfs_drop_caches (g, whattodrop);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return ULL2NUM (r);
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_dmesg (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
 
-  const char *device = StringValueCStr (devicev);
-  if (!device)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "blockdev_getsize64");
 
-  int64_t r;
+  char *r;
 
-  r = guestfs_blockdev_getsize64 (g, device);
-  if (r == -1)
+  r = guestfs_dmesg (g);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return ULL2NUM (r);
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_ping_daemon (VALUE gv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
 
-  const char *device = StringValueCStr (devicev);
-  if (!device)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "blockdev_flushbufs");
 
   int r;
 
-  r = guestfs_blockdev_flushbufs (g, device);
+  r = guestfs_ping_daemon (g);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
 
-  const char *device = StringValueCStr (devicev);
-  if (!device)
+  const char *file1 = StringValueCStr (file1v);
+  if (!file1)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "blockdev_rereadpt");
+              "file1", "equal");
+  const char *file2 = StringValueCStr (file2v);
+  if (!file2)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "file2", "equal");
 
   int r;
 
-  r = guestfs_blockdev_rereadpt (g, device);
+  r = guestfs_equal (g, file1, file2);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  return INT2NUM (r);
 }
 
-static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
+static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
 
-  const char *filename = StringValueCStr (filenamev);
-  if (!filename)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "filename", "upload");
-  const char *remotefilename = StringValueCStr (remotefilenamev);
-  if (!remotefilename)
+  const char *path = StringValueCStr (pathv);
+  if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "remotefilename", "upload");
+              "path", "strings");
 
-  int r;
+  char **r;
 
-  r = guestfs_upload (g, filename, remotefilename);
-  if (r == -1)
+  r = guestfs_strings (g, path);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
+static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
 
-  const char *remotefilename = StringValueCStr (remotefilenamev);
-  if (!remotefilename)
+  const char *encoding = StringValueCStr (encodingv);
+  if (!encoding)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "remotefilename", "download");
-  const char *filename = StringValueCStr (filenamev);
-  if (!filename)
+              "encoding", "strings_e");
+  const char *path = StringValueCStr (pathv);
+  if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "filename", "download");
+              "path", "strings_e");
 
-  int r;
+  char **r;
 
-  r = guestfs_download (g, remotefilename, filename);
-  if (r == -1)
+  r = guestfs_strings_e (g, encoding, path);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
+static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
 
-  const char *csumtype = StringValueCStr (csumtypev);
-  if (!csumtype)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "csumtype", "checksum");
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "path", "checksum");
+              "path", "hexdump");
 
   char *r;
 
-  r = guestfs_checksum (g, csumtype, path);
+  r = guestfs_hexdump (g, path);
   if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
@@ -2135,284 +3683,280 @@ static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
   return rv;
 }
 
-static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
+static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
 
-  const char *tarfile = StringValueCStr (tarfilev);
-  if (!tarfile)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "tarfile", "tar_in");
-  const char *directory = StringValueCStr (directoryv);
-  if (!directory)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "directory", "tar_in");
+              "device", "zerofree");
 
   int r;
 
-  r = guestfs_tar_in (g, tarfile, directory);
+  r = guestfs_zerofree (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
+static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
 
-  const char *directory = StringValueCStr (directoryv);
-  if (!directory)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "directory", "tar_out");
-  const char *tarfile = StringValueCStr (tarfilev);
-  if (!tarfile)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "tarfile", "tar_out");
+              "device", "pvresize");
 
   int r;
 
-  r = guestfs_tar_out (g, directory, tarfile);
+  r = guestfs_pvresize (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
+static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE nv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
 
-  const char *tarball = StringValueCStr (tarballv);
-  if (!tarball)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "tarball", "tgz_in");
-  const char *directory = StringValueCStr (directoryv);
-  if (!directory)
+              "device", "sfdisk_N");
+  int n = NUM2INT (nv);
+  int cyls = NUM2INT (cylsv);
+  int heads = NUM2INT (headsv);
+  int sectors = NUM2INT (sectorsv);
+  const char *line = StringValueCStr (linev);
+  if (!line)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "directory", "tgz_in");
+              "line", "sfdisk_N");
 
   int r;
 
-  r = guestfs_tgz_in (g, tarball, directory);
+  r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
+static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
 
-  const char *directory = StringValueCStr (directoryv);
-  if (!directory)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "directory", "tgz_out");
-  const char *tarball = StringValueCStr (tarballv);
-  if (!tarball)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "tarball", "tgz_out");
+              "device", "sfdisk_l");
 
-  int r;
+  char *r;
 
-  r = guestfs_tgz_out (g, directory, tarball);
-  if (r == -1)
+  r = guestfs_sfdisk_l (g, device);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
+static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
 
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "mount_ro");
-  const char *mountpoint = StringValueCStr (mountpointv);
-  if (!mountpoint)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "mountpoint", "mount_ro");
+              "device", "sfdisk_kernel_geometry");
 
-  int r;
+  char *r;
 
-  r = guestfs_mount_ro (g, device, mountpoint);
-  if (r == -1)
+  r = guestfs_sfdisk_kernel_geometry (g, device);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
+static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
 
-  const char *options = StringValueCStr (optionsv);
-  if (!options)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "options", "mount_options");
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "mount_options");
-  const char *mountpoint = StringValueCStr (mountpointv);
-  if (!mountpoint)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "mountpoint", "mount_options");
+              "device", "sfdisk_disk_geometry");
 
-  int r;
+  char *r;
 
-  r = guestfs_mount_options (g, options, device, mountpoint);
-  if (r == -1)
+  r = guestfs_sfdisk_disk_geometry (g, device);
+  if (r == NULL)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  return Qnil;
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
 }
 
-static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
+static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
 
-  const char *options = StringValueCStr (optionsv);
-  if (!options)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "options", "mount_vfs");
-  const char *vfstype = StringValueCStr (vfstypev);
-  if (!vfstype)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "vfstype", "mount_vfs");
-  const char *device = StringValueCStr (devicev);
-  if (!device)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "mount_vfs");
-  const char *mountpoint = StringValueCStr (mountpointv);
-  if (!mountpoint)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "mountpoint", "mount_vfs");
+  int activate = RTEST (activatev);
 
   int r;
 
-  r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
+  r = guestfs_vg_activate_all (g, activate);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
+static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
 
-  const char *subcmd = StringValueCStr (subcmdv);
-  if (!subcmd)
-    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "subcmd", "debug");
-  char **extraargs;  {
+  int activate = RTEST (activatev);
+  char **volgroups;  {
     int i, len;
-    len = RARRAY_LEN (extraargsv);
-    extraargs = malloc (sizeof (char *) * (len+1));
+    len = RARRAY_LEN (volgroupsv);
+    volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
     for (i = 0; i < len; ++i) {
-      VALUE v = rb_ary_entry (extraargsv, i);
-      extraargs[i] = StringValueCStr (v);
+      VALUE v = rb_ary_entry (volgroupsv, i);
+      volgroups[i] = StringValueCStr (v);
     }
-    extraargs[len] = NULL;
+    volgroups[len] = NULL;
   }
 
-  char *r;
+  int r;
 
-  r = guestfs_debug (g, subcmd, extraargs);
-  free (extraargs);
-  if (r == NULL)
+  r = guestfs_vg_activate (g, activate, volgroups);
+  free (volgroups);
+  if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
-  VALUE rv = rb_str_new2 (r);
-  free (r);
-  return rv;
+  return Qnil;
 }
 
-static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_lvresize (VALUE gv, VALUE devicev, VALUE mbytesv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize");
 
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "lvremove");
+              "device", "lvresize");
+  int mbytes = NUM2INT (mbytesv);
 
   int r;
 
-  r = guestfs_lvremove (g, device);
+  r = guestfs_lvresize (g, device, mbytes);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
+static VALUE ruby_guestfs_resize2fs (VALUE gv, VALUE devicev)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "resize2fs");
 
-  const char *vgname = StringValueCStr (vgnamev);
-  if (!vgname)
+  const char *device = StringValueCStr (devicev);
+  if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "vgname", "vgremove");
+              "device", "resize2fs");
 
   int r;
 
-  r = guestfs_vgremove (g, vgname);
+  r = guestfs_resize2fs (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
   return Qnil;
 }
 
-static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
+static VALUE ruby_guestfs_find (VALUE gv, VALUE directoryv)
 {
   guestfs_h *g;
   Data_Get_Struct (gv, guestfs_h, g);
   if (!g)
-    rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "find");
+
+  const char *directory = StringValueCStr (directoryv);
+  if (!directory)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "directory", "find");
+
+  char **r;
+
+  r = guestfs_find (g, directory);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  int i, len = 0;
+  for (i = 0; r[i] != NULL; ++i) len++;
+  VALUE rv = rb_ary_new2 (len);
+  for (i = 0; r[i] != NULL; ++i) {
+    rb_ary_push (rv, rb_str_new2 (r[i]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+static VALUE ruby_guestfs_e2fsck_f (VALUE gv, VALUE devicev)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f");
 
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
-              "device", "pvremove");
+              "device", "e2fsck_f");
 
   int r;
 
-  r = guestfs_pvremove (g, device);
+  r = guestfs_e2fsck_f (g, device);
   if (r == -1)
     rb_raise (e_Error, "%s", guestfs_last_error (g));
 
@@ -2429,6 +3973,60 @@ void Init__guestfs ()
   rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
   rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
 
+  rb_define_method (c_guestfs, "test0",
+        ruby_guestfs_test0, 7);
+  rb_define_method (c_guestfs, "test0rint",
+        ruby_guestfs_test0rint, 1);
+  rb_define_method (c_guestfs, "test0rinterr",
+        ruby_guestfs_test0rinterr, 0);
+  rb_define_method (c_guestfs, "test0rint64",
+        ruby_guestfs_test0rint64, 1);
+  rb_define_method (c_guestfs, "test0rint64err",
+        ruby_guestfs_test0rint64err, 0);
+  rb_define_method (c_guestfs, "test0rbool",
+        ruby_guestfs_test0rbool, 1);
+  rb_define_method (c_guestfs, "test0rboolerr",
+        ruby_guestfs_test0rboolerr, 0);
+  rb_define_method (c_guestfs, "test0rconststring",
+        ruby_guestfs_test0rconststring, 1);
+  rb_define_method (c_guestfs, "test0rconststringerr",
+        ruby_guestfs_test0rconststringerr, 0);
+  rb_define_method (c_guestfs, "test0rstring",
+        ruby_guestfs_test0rstring, 1);
+  rb_define_method (c_guestfs, "test0rstringerr",
+        ruby_guestfs_test0rstringerr, 0);
+  rb_define_method (c_guestfs, "test0rstringlist",
+        ruby_guestfs_test0rstringlist, 1);
+  rb_define_method (c_guestfs, "test0rstringlisterr",
+        ruby_guestfs_test0rstringlisterr, 0);
+  rb_define_method (c_guestfs, "test0rintbool",
+        ruby_guestfs_test0rintbool, 1);
+  rb_define_method (c_guestfs, "test0rintboolerr",
+        ruby_guestfs_test0rintboolerr, 0);
+  rb_define_method (c_guestfs, "test0rpvlist",
+        ruby_guestfs_test0rpvlist, 1);
+  rb_define_method (c_guestfs, "test0rpvlisterr",
+        ruby_guestfs_test0rpvlisterr, 0);
+  rb_define_method (c_guestfs, "test0rvglist",
+        ruby_guestfs_test0rvglist, 1);
+  rb_define_method (c_guestfs, "test0rvglisterr",
+        ruby_guestfs_test0rvglisterr, 0);
+  rb_define_method (c_guestfs, "test0rlvlist",
+        ruby_guestfs_test0rlvlist, 1);
+  rb_define_method (c_guestfs, "test0rlvlisterr",
+        ruby_guestfs_test0rlvlisterr, 0);
+  rb_define_method (c_guestfs, "test0rstat",
+        ruby_guestfs_test0rstat, 1);
+  rb_define_method (c_guestfs, "test0rstaterr",
+        ruby_guestfs_test0rstaterr, 0);
+  rb_define_method (c_guestfs, "test0rstatvfs",
+        ruby_guestfs_test0rstatvfs, 1);
+  rb_define_method (c_guestfs, "test0rstatvfserr",
+        ruby_guestfs_test0rstatvfserr, 0);
+  rb_define_method (c_guestfs, "test0rhashtable",
+        ruby_guestfs_test0rhashtable, 1);
+  rb_define_method (c_guestfs, "test0rhashtableerr",
+        ruby_guestfs_test0rhashtableerr, 0);
   rb_define_method (c_guestfs, "launch",
         ruby_guestfs_launch, 0);
   rb_define_method (c_guestfs, "wait_ready",
@@ -2439,6 +4037,8 @@ void Init__guestfs ()
         ruby_guestfs_add_drive, 1);
   rb_define_method (c_guestfs, "add_cdrom",
         ruby_guestfs_add_cdrom, 1);
+  rb_define_method (c_guestfs, "add_drive_ro",
+        ruby_guestfs_add_drive_ro, 1);
   rb_define_method (c_guestfs, "config",
         ruby_guestfs_config, 2);
   rb_define_method (c_guestfs, "set_qemu",
@@ -2449,6 +4049,10 @@ void Init__guestfs ()
         ruby_guestfs_set_path, 1);
   rb_define_method (c_guestfs, "get_path",
         ruby_guestfs_get_path, 0);
+  rb_define_method (c_guestfs, "set_append",
+        ruby_guestfs_set_append, 1);
+  rb_define_method (c_guestfs, "get_append",
+        ruby_guestfs_get_append, 0);
   rb_define_method (c_guestfs, "set_autosync",
         ruby_guestfs_set_autosync, 1);
   rb_define_method (c_guestfs, "get_autosync",
@@ -2471,6 +4075,8 @@ void Init__guestfs ()
         ruby_guestfs_set_busy, 0);
   rb_define_method (c_guestfs, "set_ready",
         ruby_guestfs_set_ready, 0);
+  rb_define_method (c_guestfs, "end_busy",
+        ruby_guestfs_end_busy, 0);
   rb_define_method (c_guestfs, "mount",
         ruby_guestfs_mount, 2);
   rb_define_method (c_guestfs, "sync",
@@ -2629,4 +4235,62 @@ void Init__guestfs ()
         ruby_guestfs_vgremove, 1);
   rb_define_method (c_guestfs, "pvremove",
         ruby_guestfs_pvremove, 1);
+  rb_define_method (c_guestfs, "set_e2label",
+        ruby_guestfs_set_e2label, 2);
+  rb_define_method (c_guestfs, "get_e2label",
+        ruby_guestfs_get_e2label, 1);
+  rb_define_method (c_guestfs, "set_e2uuid",
+        ruby_guestfs_set_e2uuid, 2);
+  rb_define_method (c_guestfs, "get_e2uuid",
+        ruby_guestfs_get_e2uuid, 1);
+  rb_define_method (c_guestfs, "fsck",
+        ruby_guestfs_fsck, 2);
+  rb_define_method (c_guestfs, "zero",
+        ruby_guestfs_zero, 1);
+  rb_define_method (c_guestfs, "grub_install",
+        ruby_guestfs_grub_install, 2);
+  rb_define_method (c_guestfs, "cp",
+        ruby_guestfs_cp, 2);
+  rb_define_method (c_guestfs, "cp_a",
+        ruby_guestfs_cp_a, 2);
+  rb_define_method (c_guestfs, "mv",
+        ruby_guestfs_mv, 2);
+  rb_define_method (c_guestfs, "drop_caches",
+        ruby_guestfs_drop_caches, 1);
+  rb_define_method (c_guestfs, "dmesg",
+        ruby_guestfs_dmesg, 0);
+  rb_define_method (c_guestfs, "ping_daemon",
+        ruby_guestfs_ping_daemon, 0);
+  rb_define_method (c_guestfs, "equal",
+        ruby_guestfs_equal, 2);
+  rb_define_method (c_guestfs, "strings",
+        ruby_guestfs_strings, 1);
+  rb_define_method (c_guestfs, "strings_e",
+        ruby_guestfs_strings_e, 2);
+  rb_define_method (c_guestfs, "hexdump",
+        ruby_guestfs_hexdump, 1);
+  rb_define_method (c_guestfs, "zerofree",
+        ruby_guestfs_zerofree, 1);
+  rb_define_method (c_guestfs, "pvresize",
+        ruby_guestfs_pvresize, 1);
+  rb_define_method (c_guestfs, "sfdisk_N",
+        ruby_guestfs_sfdisk_N, 6);
+  rb_define_method (c_guestfs, "sfdisk_l",
+        ruby_guestfs_sfdisk_l, 1);
+  rb_define_method (c_guestfs, "sfdisk_kernel_geometry",
+        ruby_guestfs_sfdisk_kernel_geometry, 1);
+  rb_define_method (c_guestfs, "sfdisk_disk_geometry",
+        ruby_guestfs_sfdisk_disk_geometry, 1);
+  rb_define_method (c_guestfs, "vg_activate_all",
+        ruby_guestfs_vg_activate_all, 1);
+  rb_define_method (c_guestfs, "vg_activate",
+        ruby_guestfs_vg_activate, 2);
+  rb_define_method (c_guestfs, "lvresize",
+        ruby_guestfs_lvresize, 2);
+  rb_define_method (c_guestfs, "resize2fs",
+        ruby_guestfs_resize2fs, 1);
+  rb_define_method (c_guestfs, "find",
+        ruby_guestfs_find, 1);
+  rb_define_method (c_guestfs, "e2fsck_f",
+        ruby_guestfs_e2fsck_f, 1);
 }