Make virt-inspector look in more places for module aliases

[libguestfs.git] / ruby / ext / guestfs / _guestfs.c

diff --git a/ruby/ext/guestfs/_guestfs.c b/ruby/ext/guestfs/_guestfs.c
index c57dcb3..5eb892f 100644 (file)
--- a/ruby/ext/guestfs/_guestfs.c
+++ b/ruby/ext/guestfs/_guestfs.c
@@ -71,6 +71,801 @@ static VALUE ruby_guestfs_close (VALUE gv)
   return Qnil;
 }
 
+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", "test0");
+
+  Check_Type (strv, T_STRING);
+  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;
+  Check_Type (strlistv, T_ARRAY);
+  {
+    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);
+  Check_Type (fileinv, T_STRING);
+  const char *filein = StringValueCStr (fileinv);
+  if (!filein)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "filein", "test0");
+  Check_Type (fileoutv, T_STRING);
+  const char *fileout = StringValueCStr (fileoutv);
+  if (!fileout)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "fileout", "test0");
+
+  int r;
+
+  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_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", "test0rint");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rint");
+
+  int r;
+
+  r = guestfs_test0rint (g, val);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+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", "test0rinterr");
+
+
+  int r;
+
+  r = guestfs_test0rinterr (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+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", "test0rint64");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rint64");
+
+  int64_t r;
+
+  r = guestfs_test0rint64 (g, val);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return ULL2NUM (r);
+}
+
+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", "test0rint64err");
+
+
+  int64_t r;
+
+  r = guestfs_test0rint64err (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return ULL2NUM (r);
+}
+
+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", "test0rbool");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rbool");
+
+  int r;
+
+  r = guestfs_test0rbool (g, val);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+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", "test0rboolerr");
+
+
+  int r;
+
+  r = guestfs_test0rboolerr (g);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+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", "test0rconststring");
+
+  Check_Type (valv, T_STRING);
+  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_test0rconststring (g, val);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return rb_str_new2 (r);
+}
+
+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", "test0rconststringerr");
+
+
+  const char *r;
+
+  r = guestfs_test0rconststringerr (g);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return rb_str_new2 (r);
+}
+
+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", "test0rstring");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rstring");
+
+  char *r;
+
+  r = guestfs_test0rstring (g, val);
+  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_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", "test0rstringerr");
+
+
+  char *r;
+
+  r = guestfs_test0rstringerr (g);
+  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_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", "test0rstringlist");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rstringlist");
+
+  char **r;
+
+  r = guestfs_test0rstringlist (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]));
+    free (r[i]);
+  }
+  free (r);
+  return rv;
+}
+
+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", "test0rstringlisterr");
+
+
+  char **r;
+
+  r = guestfs_test0rstringlisterr (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_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", "test0rintbool");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rintbool");
+
+  struct guestfs_int_bool *r;
+
+  r = guestfs_test0rintbool (g, 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_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", "test0rintboolerr");
+
+
+  struct guestfs_int_bool *r;
+
+  r = guestfs_test0rintboolerr (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);
+  return rv;
+}
+
+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", "test0rpvlist");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rpvlist");
+
+  struct guestfs_lvm_pv_list *r;
+
+  r = guestfs_test0rpvlist (g, val);
+  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_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", "test0rpvlisterr");
+
+
+  struct guestfs_lvm_pv_list *r;
+
+  r = guestfs_test0rpvlisterr (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_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", "test0rvglist");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rvglist");
+
+  struct guestfs_lvm_vg_list *r;
+
+  r = guestfs_test0rvglist (g, val);
+  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_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", "test0rvglisterr");
+
+
+  struct guestfs_lvm_vg_list *r;
+
+  r = guestfs_test0rvglisterr (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_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", "test0rlvlist");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rlvlist");
+
+  struct guestfs_lvm_lv_list *r;
+
+  r = guestfs_test0rlvlist (g, val);
+  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_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", "test0rlvlisterr");
+
+
+  struct guestfs_lvm_lv_list *r;
+
+  r = guestfs_test0rlvlisterr (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_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", "test0rstat");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rstat");
+
+  struct guestfs_stat *r;
+
+  r = guestfs_test0rstat (g, val);
+  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));
+  free (r);
+  return rv;
+}
+
+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", "test0rstaterr");
+
+
+  struct guestfs_stat *r;
+
+  r = guestfs_test0rstaterr (g);
+  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));
+  free (r);
+  return rv;
+}
+
+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", "test0rstatvfs");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rstatvfs");
+
+  struct guestfs_statvfs *r;
+
+  r = guestfs_test0rstatvfs (g, val);
+  if (r == NULL)
+    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;
+}
+
+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", "test0rstatvfserr");
+
+
+  struct guestfs_statvfs *r;
+
+  r = guestfs_test0rstatvfserr (g);
+  if (r == NULL)
+    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;
+}
+
+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", "test0rhashtable");
+
+  Check_Type (valv, T_STRING);
+  const char *val = StringValueCStr (valv);
+  if (!val)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "val", "test0rhashtable");
+
+  char **r;
+
+  r = guestfs_test0rhashtable (g, val);
+  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]);
+  }
+  free (r);
+  return rv;
+}
+
+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", "test0rhashtableerr");
+
+
+  char **r;
+
+  r = guestfs_test0rhashtableerr (g);
+  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]);
+  }
+  free (r);
+  return rv;
+}
+
 static VALUE ruby_guestfs_launch (VALUE gv)
 {
   guestfs_h *g;
@@ -129,6 +924,7 @@ static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
 
+  Check_Type (filenamev, T_STRING);
   const char *filename = StringValueCStr (filenamev);
   if (!filename)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -150,6 +946,7 @@ static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
 
+  Check_Type (filenamev, T_STRING);
   const char *filename = StringValueCStr (filenamev);
   if (!filename)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -164,6 +961,28 @@ static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
   return Qnil;
 }
 
+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", "add_drive_ro");
+
+  Check_Type (filenamev, T_STRING);
+  const char *filename = StringValueCStr (filenamev);
+  if (!filename)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "filename", "add_drive_ro");
+
+  int r;
+
+  r = guestfs_add_drive_ro (g, filename);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
 {
   guestfs_h *g;
@@ -171,11 +990,12 @@ static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
 
+  Check_Type (qemuparamv, T_STRING);
   const char *qemuparam = StringValueCStr (qemuparamv);
   if (!qemuparam)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "qemuparam", "config");
-  const char *qemuvalue = StringValueCStr (qemuvaluev);
+  const char *qemuvalue = !NIL_P (qemuvaluev) ? StringValueCStr (qemuvaluev) : NULL;
 
   int r;
 
@@ -193,6 +1013,7 @@ static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
 
+  Check_Type (qemuv, T_STRING);
   const char *qemu = StringValueCStr (qemuv);
   if (!qemu)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -231,6 +1052,7 @@ static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -269,6 +1091,7 @@ static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_append");
 
+  Check_Type (appendv, T_STRING);
   const char *append = StringValueCStr (appendv);
   if (!append)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -307,7 +1130,7 @@ static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
 
-  int autosync = NUM2INT (autosyncv);
+  int autosync = RTEST (autosyncv);
 
   int r;
 
@@ -342,7 +1165,7 @@ static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
 
-  int verbose = NUM2INT (verbosev);
+  int verbose = RTEST (verbosev);
 
   int r;
 
@@ -513,10 +1336,12 @@ static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "device", "mount");
+  Check_Type (mountpointv, T_STRING);
   const char *mountpoint = StringValueCStr (mountpointv);
   if (!mountpoint)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -555,6 +1380,7 @@ static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -576,6 +1402,7 @@ static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -599,6 +1426,7 @@ static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
 
+  Check_Type (directoryv, T_STRING);
   const char *directory = StringValueCStr (directoryv);
   if (!directory)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -622,6 +1450,7 @@ static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
 
+  Check_Type (directoryv, T_STRING);
   const char *directory = StringValueCStr (directoryv);
   if (!directory)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -897,6 +1726,7 @@ static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -926,6 +1756,7 @@ static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
 
+  Check_Type (rootv, T_STRING);
   const char *root = StringValueCStr (rootv);
   if (!root)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -965,11 +1796,12 @@ static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
 
+  Check_Type (namev, T_STRING);
   const char *name = StringValueCStr (namev);
   if (!name)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "name", "aug_defvar");
-  const char *expr = StringValueCStr (exprv);
+  const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL;
 
   int r;
 
@@ -987,14 +1819,17 @@ static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
 
+  Check_Type (namev, T_STRING);
   const char *name = StringValueCStr (namev);
   if (!name)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "name", "aug_defnode");
+  Check_Type (exprv, T_STRING);
   const char *expr = StringValueCStr (exprv);
   if (!expr)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "expr", "aug_defnode");
+  Check_Type (valv, T_STRING);
   const char *val = StringValueCStr (valv);
   if (!val)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1020,6 +1855,7 @@ static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1043,10 +1879,12 @@ static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "path", "aug_set");
+  Check_Type (valv, T_STRING);
   const char *val = StringValueCStr (valv);
   if (!val)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1068,15 +1906,17 @@ static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "path", "aug_insert");
+  Check_Type (labelv, T_STRING);
   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);
+  int before = RTEST (beforev);
 
   int r;
 
@@ -1094,6 +1934,7 @@ static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1115,10 +1956,12 @@ static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
 
+  Check_Type (srcv, T_STRING);
   const char *src = StringValueCStr (srcv);
   if (!src)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "src", "aug_mv");
+  Check_Type (destv, T_STRING);
   const char *dest = StringValueCStr (destv);
   if (!dest)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1140,6 +1983,7 @@ static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1203,6 +2047,7 @@ static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1232,6 +2077,7 @@ static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1253,6 +2099,7 @@ static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1274,6 +2121,7 @@ static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1295,6 +2143,7 @@ static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1316,6 +2165,7 @@ static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1338,6 +2188,7 @@ static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
 
   int mode = NUM2INT (modev);
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1361,6 +2212,7 @@ static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pat
 
   int owner = NUM2INT (ownerv);
   int group = NUM2INT (groupv);
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1382,6 +2234,7 @@ static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1403,6 +2256,7 @@ static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1424,6 +2278,7 @@ static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1445,6 +2300,7 @@ static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1466,11 +2322,14 @@ static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
 
+  Check_Type (volgroupv, T_STRING);
   const char *volgroup = StringValueCStr (volgroupv);
   if (!volgroup)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "volgroup", "vgcreate");
-  char **physvols;  {
+  char **physvols;
+  Check_Type (physvolsv, T_ARRAY);
+  {
     int i, len;
     len = RARRAY_LEN (physvolsv);
     physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
@@ -1498,10 +2357,12 @@ static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VA
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
 
+  Check_Type (logvolv, T_STRING);
   const char *logvol = StringValueCStr (logvolv);
   if (!logvol)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "logvol", "lvcreate");
+  Check_Type (volgroupv, T_STRING);
   const char *volgroup = StringValueCStr (volgroupv);
   if (!volgroup)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1524,10 +2385,12 @@ static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
 
+  Check_Type (fstypev, T_STRING);
   const char *fstype = StringValueCStr (fstypev);
   if (!fstype)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "fstype", "mkfs");
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1549,6 +2412,7 @@ static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE he
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1556,7 +2420,9 @@ static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE he
   int cyls = NUM2INT (cylsv);
   int heads = NUM2INT (headsv);
   int sectors = NUM2INT (sectorsv);
-  char **lines;  {
+  char **lines;
+  Check_Type (linesv, T_ARRAY);
+  {
     int i, len;
     len = RARRAY_LEN (linesv);
     lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
@@ -1584,10 +2450,12 @@ static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VAL
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "path", "write_file");
+  Check_Type (contentv, T_STRING);
   const char *content = StringValueCStr (contentv);
   if (!content)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1610,6 +2478,7 @@ static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
 
+  Check_Type (pathordevicev, T_STRING);
   const char *pathordevice = StringValueCStr (pathordevicev);
   if (!pathordevice)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1690,6 +2559,7 @@ static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1713,7 +2583,9 @@ static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
 
-  char **arguments;  {
+  char **arguments;
+  Check_Type (argumentsv, T_ARRAY);
+  {
     int i, len;
     len = RARRAY_LEN (argumentsv);
     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
@@ -1743,7 +2615,9 @@ static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
 
-  char **arguments;  {
+  char **arguments;
+  Check_Type (argumentsv, T_ARRAY);
+  {
     int i, len;
     len = RARRAY_LEN (argumentsv);
     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
@@ -1779,6 +2653,7 @@ static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1815,6 +2690,7 @@ static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1851,6 +2727,7 @@ static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1885,6 +2762,7 @@ static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1914,6 +2792,7 @@ static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1935,6 +2814,7 @@ static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1956,6 +2836,7 @@ static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1977,6 +2858,7 @@ static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -1998,6 +2880,7 @@ static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2019,6 +2902,7 @@ static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocks
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2041,6 +2925,7 @@ static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2062,6 +2947,7 @@ static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2083,6 +2969,7 @@ static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2104,6 +2991,7 @@ static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2125,10 +3013,12 @@ static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenam
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
 
+  Check_Type (filenamev, T_STRING);
   const char *filename = StringValueCStr (filenamev);
   if (!filename)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "filename", "upload");
+  Check_Type (remotefilenamev, T_STRING);
   const char *remotefilename = StringValueCStr (remotefilenamev);
   if (!remotefilename)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2150,10 +3040,12 @@ static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filen
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
 
+  Check_Type (remotefilenamev, T_STRING);
   const char *remotefilename = StringValueCStr (remotefilenamev);
   if (!remotefilename)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "remotefilename", "download");
+  Check_Type (filenamev, T_STRING);
   const char *filename = StringValueCStr (filenamev);
   if (!filename)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2175,10 +3067,12 @@ static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
 
+  Check_Type (csumtypev, T_STRING);
   const char *csumtype = StringValueCStr (csumtypev);
   if (!csumtype)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "csumtype", "checksum");
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2202,10 +3096,12 @@ static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
 
+  Check_Type (tarfilev, T_STRING);
   const char *tarfile = StringValueCStr (tarfilev);
   if (!tarfile)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "tarfile", "tar_in");
+  Check_Type (directoryv, T_STRING);
   const char *directory = StringValueCStr (directoryv);
   if (!directory)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2227,10 +3123,12 @@ static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
 
+  Check_Type (directoryv, T_STRING);
   const char *directory = StringValueCStr (directoryv);
   if (!directory)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "directory", "tar_out");
+  Check_Type (tarfilev, T_STRING);
   const char *tarfile = StringValueCStr (tarfilev);
   if (!tarfile)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2252,10 +3150,12 @@ static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
 
+  Check_Type (tarballv, T_STRING);
   const char *tarball = StringValueCStr (tarballv);
   if (!tarball)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "tarball", "tgz_in");
+  Check_Type (directoryv, T_STRING);
   const char *directory = StringValueCStr (directoryv);
   if (!directory)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2277,10 +3177,12 @@ static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
 
+  Check_Type (directoryv, T_STRING);
   const char *directory = StringValueCStr (directoryv);
   if (!directory)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "directory", "tgz_out");
+  Check_Type (tarballv, T_STRING);
   const char *tarball = StringValueCStr (tarballv);
   if (!tarball)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2302,10 +3204,12 @@ static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "device", "mount_ro");
+  Check_Type (mountpointv, T_STRING);
   const char *mountpoint = StringValueCStr (mountpointv);
   if (!mountpoint)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2327,14 +3231,17 @@ static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
 
+  Check_Type (optionsv, T_STRING);
   const char *options = StringValueCStr (optionsv);
   if (!options)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "options", "mount_options");
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "device", "mount_options");
+  Check_Type (mountpointv, T_STRING);
   const char *mountpoint = StringValueCStr (mountpointv);
   if (!mountpoint)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2356,18 +3263,22 @@ static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, V
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
 
+  Check_Type (optionsv, T_STRING);
   const char *options = StringValueCStr (optionsv);
   if (!options)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "options", "mount_vfs");
+  Check_Type (vfstypev, T_STRING);
   const char *vfstype = StringValueCStr (vfstypev);
   if (!vfstype)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "vfstype", "mount_vfs");
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "device", "mount_vfs");
+  Check_Type (mountpointv, T_STRING);
   const char *mountpoint = StringValueCStr (mountpointv);
   if (!mountpoint)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2389,11 +3300,14 @@ static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
 
+  Check_Type (subcmdv, T_STRING);
   const char *subcmd = StringValueCStr (subcmdv);
   if (!subcmd)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "subcmd", "debug");
-  char **extraargs;  {
+  char **extraargs;
+  Check_Type (extraargsv, T_ARRAY);
+  {
     int i, len;
     len = RARRAY_LEN (extraargsv);
     extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
@@ -2423,6 +3337,7 @@ static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2444,6 +3359,7 @@ static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
 
+  Check_Type (vgnamev, T_STRING);
   const char *vgname = StringValueCStr (vgnamev);
   if (!vgname)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2465,6 +3381,7 @@ static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2486,10 +3403,12 @@ static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "device", "set_e2label");
+  Check_Type (labelv, T_STRING);
   const char *label = StringValueCStr (labelv);
   if (!label)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2511,6 +3430,7 @@ static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2534,10 +3454,12 @@ static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "device", "set_e2uuid");
+  Check_Type (uuidv, T_STRING);
   const char *uuid = StringValueCStr (uuidv);
   if (!uuid)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2559,6 +3481,7 @@ static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2582,10 +3505,12 @@ static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
 
+  Check_Type (fstypev, T_STRING);
   const char *fstype = StringValueCStr (fstypev);
   if (!fstype)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "fstype", "fsck");
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2607,6 +3532,7 @@ static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2628,10 +3554,12 @@ static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
 
+  Check_Type (rootv, T_STRING);
   const char *root = StringValueCStr (rootv);
   if (!root)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "root", "grub_install");
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2653,10 +3581,12 @@ static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
 
+  Check_Type (srcv, T_STRING);
   const char *src = StringValueCStr (srcv);
   if (!src)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "src", "cp");
+  Check_Type (destv, T_STRING);
   const char *dest = StringValueCStr (destv);
   if (!dest)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2678,10 +3608,12 @@ static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
 
+  Check_Type (srcv, T_STRING);
   const char *src = StringValueCStr (srcv);
   if (!src)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "src", "cp_a");
+  Check_Type (destv, T_STRING);
   const char *dest = StringValueCStr (destv);
   if (!dest)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2703,10 +3635,12 @@ static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
 
+  Check_Type (srcv, T_STRING);
   const char *src = StringValueCStr (srcv);
   if (!src)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "src", "mv");
+  Check_Type (destv, T_STRING);
   const char *dest = StringValueCStr (destv);
   if (!dest)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2782,10 +3716,12 @@ static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
 
+  Check_Type (file1v, T_STRING);
   const char *file1 = StringValueCStr (file1v);
   if (!file1)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "file1", "equal");
+  Check_Type (file2v, T_STRING);
   const char *file2 = StringValueCStr (file2v);
   if (!file2)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2807,6 +3743,7 @@ static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2836,10 +3773,12 @@ static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
 
+  Check_Type (encodingv, T_STRING);
   const char *encoding = StringValueCStr (encodingv);
   if (!encoding)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
               "encoding", "strings_e");
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2869,6 +3808,7 @@ static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
 
+  Check_Type (pathv, T_STRING);
   const char *path = StringValueCStr (pathv);
   if (!path)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2892,6 +3832,7 @@ static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2913,6 +3854,7 @@ static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2934,6 +3876,7 @@ static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE nv, VALUE cyl
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2942,6 +3885,7 @@ static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE nv, VALUE cyl
   int cyls = NUM2INT (cylsv);
   int heads = NUM2INT (headsv);
   int sectors = NUM2INT (sectorsv);
+  Check_Type (linev, T_STRING);
   const char *line = StringValueCStr (linev);
   if (!line)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2963,6 +3907,7 @@ static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -2986,6 +3931,7 @@ static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -3009,6 +3955,7 @@ static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
 
+  Check_Type (devicev, T_STRING);
   const char *device = StringValueCStr (devicev);
   if (!device)
     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
@@ -3032,7 +3979,7 @@ static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
 
-  int activate = NUM2INT (activatev);
+  int activate = RTEST (activatev);
 
   int r;
 
@@ -3050,8 +3997,10 @@ static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroup
   if (!g)
     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
 
-  int activate = NUM2INT (activatev);
-  char **volgroups;  {
+  int activate = RTEST (activatev);
+  char **volgroups;
+  Check_Type (volgroupsv, T_ARRAY);
+  {
     int i, len;
     len = RARRAY_LEN (volgroupsv);
     volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
@@ -3072,6 +4021,318 @@ static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroup
   return Qnil;
 }
 
+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", "lvresize");
+
+  Check_Type (devicev, T_STRING);
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "lvresize");
+  int mbytes = NUM2INT (mbytesv);
+
+  int r;
+
+  r = guestfs_lvresize (g, device, mbytes);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+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", "resize2fs");
+
+  Check_Type (devicev, T_STRING);
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "resize2fs");
+
+  int r;
+
+  r = guestfs_resize2fs (g, device);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+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", "find");
+
+  Check_Type (directoryv, T_STRING);
+  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");
+
+  Check_Type (devicev, T_STRING);
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "e2fsck_f");
+
+  int r;
+
+  r = guestfs_e2fsck_f (g, device);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_sleep (VALUE gv, VALUE secsv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "sleep");
+
+  int secs = NUM2INT (secsv);
+
+  int r;
+
+  r = guestfs_sleep (g, secs);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_ntfs_3g_probe (VALUE gv, VALUE rwv, VALUE devicev)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "ntfs_3g_probe");
+
+  int rw = RTEST (rwv);
+  Check_Type (devicev, T_STRING);
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "ntfs_3g_probe");
+
+  int r;
+
+  r = guestfs_ntfs_3g_probe (g, rw, device);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return INT2NUM (r);
+}
+
+static VALUE ruby_guestfs_sh (VALUE gv, VALUE commandv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "sh");
+
+  Check_Type (commandv, T_STRING);
+  const char *command = StringValueCStr (commandv);
+  if (!command)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "command", "sh");
+
+  char *r;
+
+  r = guestfs_sh (g, command);
+  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_sh_lines (VALUE gv, VALUE commandv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "sh_lines");
+
+  Check_Type (commandv, T_STRING);
+  const char *command = StringValueCStr (commandv);
+  if (!command)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "command", "sh_lines");
+
+  char **r;
+
+  r = guestfs_sh_lines (g, command);
+  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_glob_expand (VALUE gv, VALUE patternv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "glob_expand");
+
+  Check_Type (patternv, T_STRING);
+  const char *pattern = StringValueCStr (patternv);
+  if (!pattern)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "pattern", "glob_expand");
+
+  char **r;
+
+  r = guestfs_glob_expand (g, pattern);
+  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_scrub_device (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", "scrub_device");
+
+  Check_Type (devicev, T_STRING);
+  const char *device = StringValueCStr (devicev);
+  if (!device)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "device", "scrub_device");
+
+  int r;
+
+  r = guestfs_scrub_device (g, device);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_scrub_file (VALUE gv, VALUE filev)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_file");
+
+  Check_Type (filev, T_STRING);
+  const char *file = StringValueCStr (filev);
+  if (!file)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "file", "scrub_file");
+
+  int r;
+
+  r = guestfs_scrub_file (g, file);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_scrub_freespace (VALUE gv, VALUE dirv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "scrub_freespace");
+
+  Check_Type (dirv, T_STRING);
+  const char *dir = StringValueCStr (dirv);
+  if (!dir)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "dir", "scrub_freespace");
+
+  int r;
+
+  r = guestfs_scrub_freespace (g, dir);
+  if (r == -1)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  return Qnil;
+}
+
+static VALUE ruby_guestfs_mkdtemp (VALUE gv, VALUE templatev)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+  if (!g)
+    rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdtemp");
+
+  Check_Type (templatev, T_STRING);
+  const char *template = StringValueCStr (templatev);
+  if (!template)
+    rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
+              "template", "mkdtemp");
+
+  char *r;
+
+  r = guestfs_mkdtemp (g, template);
+  if (r == NULL)
+    rb_raise (e_Error, "%s", guestfs_last_error (g));
+
+  VALUE rv = rb_str_new2 (r);
+  free (r);
+  return rv;
+}
+
 /* Initialize the module. */
 void Init__guestfs ()
 {
@@ -3082,6 +4343,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",
@@ -3092,6 +4407,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",
@@ -3338,4 +4655,30 @@ void Init__guestfs ()
         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);
+  rb_define_method (c_guestfs, "sleep",
+        ruby_guestfs_sleep, 1);
+  rb_define_method (c_guestfs, "ntfs_3g_probe",
+        ruby_guestfs_ntfs_3g_probe, 2);
+  rb_define_method (c_guestfs, "sh",
+        ruby_guestfs_sh, 1);
+  rb_define_method (c_guestfs, "sh_lines",
+        ruby_guestfs_sh_lines, 1);
+  rb_define_method (c_guestfs, "glob_expand",
+        ruby_guestfs_glob_expand, 1);
+  rb_define_method (c_guestfs, "scrub_device",
+        ruby_guestfs_scrub_device, 1);
+  rb_define_method (c_guestfs, "scrub_file",
+        ruby_guestfs_scrub_file, 1);
+  rb_define_method (c_guestfs, "scrub_freespace",
+        ruby_guestfs_scrub_freespace, 1);
+  rb_define_method (c_guestfs, "mkdtemp",
+        ruby_guestfs_mkdtemp, 1);
 }