ruby/ext/guestfs/_guestfs.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #include <ruby.h>
  26
  27 #include "guestfs.h"
  28
  29 #include "extconf.h"
  30
  31 /* For Ruby < 1.9 */
  32 #ifndef RARRAY_LEN
  33 #define RARRAY_LEN(r) (RARRAY((r))->len)
  34 #endif
  35
  36 static VALUE m_guestfs;                 /* guestfs module */
  37 static VALUE c_guestfs;                 /* guestfs_h handle */
  38 static VALUE e_Error;                   /* used for all errors */
  39
  40 static void ruby_guestfs_free (void *p)
  41 {
  42   if (!p) return;
  43   guestfs_close ((guestfs_h *) p);
  44 }
  45
  46 static VALUE ruby_guestfs_create (VALUE m)
  47 {
  48   guestfs_h *g;
  49
  50   g = guestfs_create ();
  51   if (!g)
  52     rb_raise (e_Error, "failed to create guestfs handle");
  53
  54   /* Don't print error messages to stderr by default. */
  55   guestfs_set_error_handler (g, NULL, NULL);
  56
  57   /* Wrap it, and make sure the close function is called when the
  58    * handle goes away.
  59    */
  60   return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
  61 }
  62
  63 static VALUE ruby_guestfs_close (VALUE gv)
  64 {
  65   guestfs_h *g;
  66   Data_Get_Struct (gv, guestfs_h, g);
  67
  68   ruby_guestfs_free (g);
  69   DATA_PTR (gv) = NULL;
  70
  71   return Qnil;
  72 }
  73
  74 static VALUE ruby_guestfs_test0 (VALUE gv, VALUE strv, VALUE optstrv, VALUE strlistv, VALUE bv, VALUE integerv, VALUE fileinv, VALUE fileoutv)
  75 {
  76   guestfs_h *g;
  77   Data_Get_Struct (gv, guestfs_h, g);
  78   if (!g)
  79     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0");
  80
  81   const char *str = StringValueCStr (strv);
  82   if (!str)
  83     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
  84               "str", "test0");
  85   const char *optstr = StringValueCStr (optstrv);
  86   char **strlist;  {
  87     int i, len;
  88     len = RARRAY_LEN (strlistv);
  89     strlist = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
  90     for (i = 0; i < len; ++i) {
  91       VALUE v = rb_ary_entry (strlistv, i);
  92       strlist[i] = StringValueCStr (v);
  93     }
  94     strlist[len] = NULL;
  95   }
  96   int b = NUM2INT (bv);
  97   int integer = NUM2INT (integerv);
  98   const char *filein = StringValueCStr (fileinv);
  99   if (!filein)
 100     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 101               "filein", "test0");
 102   const char *fileout = StringValueCStr (fileoutv);
 103   if (!fileout)
 104     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 105               "fileout", "test0");
 106
 107   int r;
 108
 109   r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
 110   free (strlist);
 111   if (r == -1)
 112     rb_raise (e_Error, "%s", guestfs_last_error (g));
 113
 114   return Qnil;
 115 }
 116
 117 static VALUE ruby_guestfs_test0rint (VALUE gv, VALUE valv)
 118 {
 119   guestfs_h *g;
 120   Data_Get_Struct (gv, guestfs_h, g);
 121   if (!g)
 122     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint");
 123
 124   const char *val = StringValueCStr (valv);
 125   if (!val)
 126     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 127               "val", "test0rint");
 128
 129   int r;
 130
 131   r = guestfs_test0rint (g, val);
 132   if (r == -1)
 133     rb_raise (e_Error, "%s", guestfs_last_error (g));
 134
 135   return INT2NUM (r);
 136 }
 137
 138 static VALUE ruby_guestfs_test0rinterr (VALUE gv)
 139 {
 140   guestfs_h *g;
 141   Data_Get_Struct (gv, guestfs_h, g);
 142   if (!g)
 143     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rinterr");
 144
 145
 146   int r;
 147
 148   r = guestfs_test0rinterr (g);
 149   if (r == -1)
 150     rb_raise (e_Error, "%s", guestfs_last_error (g));
 151
 152   return INT2NUM (r);
 153 }
 154
 155 static VALUE ruby_guestfs_test0rint64 (VALUE gv, VALUE valv)
 156 {
 157   guestfs_h *g;
 158   Data_Get_Struct (gv, guestfs_h, g);
 159   if (!g)
 160     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64");
 161
 162   const char *val = StringValueCStr (valv);
 163   if (!val)
 164     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 165               "val", "test0rint64");
 166
 167   int64_t r;
 168
 169   r = guestfs_test0rint64 (g, val);
 170   if (r == -1)
 171     rb_raise (e_Error, "%s", guestfs_last_error (g));
 172
 173   return ULL2NUM (r);
 174 }
 175
 176 static VALUE ruby_guestfs_test0rint64err (VALUE gv)
 177 {
 178   guestfs_h *g;
 179   Data_Get_Struct (gv, guestfs_h, g);
 180   if (!g)
 181     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rint64err");
 182
 183
 184   int64_t r;
 185
 186   r = guestfs_test0rint64err (g);
 187   if (r == -1)
 188     rb_raise (e_Error, "%s", guestfs_last_error (g));
 189
 190   return ULL2NUM (r);
 191 }
 192
 193 static VALUE ruby_guestfs_test0rbool (VALUE gv, VALUE valv)
 194 {
 195   guestfs_h *g;
 196   Data_Get_Struct (gv, guestfs_h, g);
 197   if (!g)
 198     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rbool");
 199
 200   const char *val = StringValueCStr (valv);
 201   if (!val)
 202     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 203               "val", "test0rbool");
 204
 205   int r;
 206
 207   r = guestfs_test0rbool (g, val);
 208   if (r == -1)
 209     rb_raise (e_Error, "%s", guestfs_last_error (g));
 210
 211   return INT2NUM (r);
 212 }
 213
 214 static VALUE ruby_guestfs_test0rboolerr (VALUE gv)
 215 {
 216   guestfs_h *g;
 217   Data_Get_Struct (gv, guestfs_h, g);
 218   if (!g)
 219     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rboolerr");
 220
 221
 222   int r;
 223
 224   r = guestfs_test0rboolerr (g);
 225   if (r == -1)
 226     rb_raise (e_Error, "%s", guestfs_last_error (g));
 227
 228   return INT2NUM (r);
 229 }
 230
 231 static VALUE ruby_guestfs_test0rconststring (VALUE gv, VALUE valv)
 232 {
 233   guestfs_h *g;
 234   Data_Get_Struct (gv, guestfs_h, g);
 235   if (!g)
 236     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststring");
 237
 238   const char *val = StringValueCStr (valv);
 239   if (!val)
 240     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 241               "val", "test0rconststring");
 242
 243   const char *r;
 244
 245   r = guestfs_test0rconststring (g, val);
 246   if (r == NULL)
 247     rb_raise (e_Error, "%s", guestfs_last_error (g));
 248
 249   return rb_str_new2 (r);
 250 }
 251
 252 static VALUE ruby_guestfs_test0rconststringerr (VALUE gv)
 253 {
 254   guestfs_h *g;
 255   Data_Get_Struct (gv, guestfs_h, g);
 256   if (!g)
 257     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rconststringerr");
 258
 259
 260   const char *r;
 261
 262   r = guestfs_test0rconststringerr (g);
 263   if (r == NULL)
 264     rb_raise (e_Error, "%s", guestfs_last_error (g));
 265
 266   return rb_str_new2 (r);
 267 }
 268
 269 static VALUE ruby_guestfs_test0rstring (VALUE gv, VALUE valv)
 270 {
 271   guestfs_h *g;
 272   Data_Get_Struct (gv, guestfs_h, g);
 273   if (!g)
 274     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstring");
 275
 276   const char *val = StringValueCStr (valv);
 277   if (!val)
 278     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 279               "val", "test0rstring");
 280
 281   char *r;
 282
 283   r = guestfs_test0rstring (g, val);
 284   if (r == NULL)
 285     rb_raise (e_Error, "%s", guestfs_last_error (g));
 286
 287   VALUE rv = rb_str_new2 (r);
 288   free (r);
 289   return rv;
 290 }
 291
 292 static VALUE ruby_guestfs_test0rstringerr (VALUE gv)
 293 {
 294   guestfs_h *g;
 295   Data_Get_Struct (gv, guestfs_h, g);
 296   if (!g)
 297     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringerr");
 298
 299
 300   char *r;
 301
 302   r = guestfs_test0rstringerr (g);
 303   if (r == NULL)
 304     rb_raise (e_Error, "%s", guestfs_last_error (g));
 305
 306   VALUE rv = rb_str_new2 (r);
 307   free (r);
 308   return rv;
 309 }
 310
 311 static VALUE ruby_guestfs_test0rstringlist (VALUE gv, VALUE valv)
 312 {
 313   guestfs_h *g;
 314   Data_Get_Struct (gv, guestfs_h, g);
 315   if (!g)
 316     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlist");
 317
 318   const char *val = StringValueCStr (valv);
 319   if (!val)
 320     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 321               "val", "test0rstringlist");
 322
 323   char **r;
 324
 325   r = guestfs_test0rstringlist (g, val);
 326   if (r == NULL)
 327     rb_raise (e_Error, "%s", guestfs_last_error (g));
 328
 329   int i, len = 0;
 330   for (i = 0; r[i] != NULL; ++i) len++;
 331   VALUE rv = rb_ary_new2 (len);
 332   for (i = 0; r[i] != NULL; ++i) {
 333     rb_ary_push (rv, rb_str_new2 (r[i]));
 334     free (r[i]);
 335   }
 336   free (r);
 337   return rv;
 338 }
 339
 340 static VALUE ruby_guestfs_test0rstringlisterr (VALUE gv)
 341 {
 342   guestfs_h *g;
 343   Data_Get_Struct (gv, guestfs_h, g);
 344   if (!g)
 345     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstringlisterr");
 346
 347
 348   char **r;
 349
 350   r = guestfs_test0rstringlisterr (g);
 351   if (r == NULL)
 352     rb_raise (e_Error, "%s", guestfs_last_error (g));
 353
 354   int i, len = 0;
 355   for (i = 0; r[i] != NULL; ++i) len++;
 356   VALUE rv = rb_ary_new2 (len);
 357   for (i = 0; r[i] != NULL; ++i) {
 358     rb_ary_push (rv, rb_str_new2 (r[i]));
 359     free (r[i]);
 360   }
 361   free (r);
 362   return rv;
 363 }
 364
 365 static VALUE ruby_guestfs_test0rintbool (VALUE gv, VALUE valv)
 366 {
 367   guestfs_h *g;
 368   Data_Get_Struct (gv, guestfs_h, g);
 369   if (!g)
 370     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintbool");
 371
 372   const char *val = StringValueCStr (valv);
 373   if (!val)
 374     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 375               "val", "test0rintbool");
 376
 377   struct guestfs_int_bool *r;
 378
 379   r = guestfs_test0rintbool (g, val);
 380   if (r == NULL)
 381     rb_raise (e_Error, "%s", guestfs_last_error (g));
 382
 383   VALUE rv = rb_ary_new2 (2);
 384   rb_ary_push (rv, INT2NUM (r->i));
 385   rb_ary_push (rv, INT2NUM (r->b));
 386   guestfs_free_int_bool (r);
 387   return rv;
 388 }
 389
 390 static VALUE ruby_guestfs_test0rintboolerr (VALUE gv)
 391 {
 392   guestfs_h *g;
 393   Data_Get_Struct (gv, guestfs_h, g);
 394   if (!g)
 395     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rintboolerr");
 396
 397
 398   struct guestfs_int_bool *r;
 399
 400   r = guestfs_test0rintboolerr (g);
 401   if (r == NULL)
 402     rb_raise (e_Error, "%s", guestfs_last_error (g));
 403
 404   VALUE rv = rb_ary_new2 (2);
 405   rb_ary_push (rv, INT2NUM (r->i));
 406   rb_ary_push (rv, INT2NUM (r->b));
 407   guestfs_free_int_bool (r);
 408   return rv;
 409 }
 410
 411 static VALUE ruby_guestfs_test0rpvlist (VALUE gv, VALUE valv)
 412 {
 413   guestfs_h *g;
 414   Data_Get_Struct (gv, guestfs_h, g);
 415   if (!g)
 416     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlist");
 417
 418   const char *val = StringValueCStr (valv);
 419   if (!val)
 420     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 421               "val", "test0rpvlist");
 422
 423   struct guestfs_lvm_pv_list *r;
 424
 425   r = guestfs_test0rpvlist (g, val);
 426   if (r == NULL)
 427     rb_raise (e_Error, "%s", guestfs_last_error (g));
 428
 429   VALUE rv = rb_ary_new2 (r->len);
 430   int i;
 431   for (i = 0; i < r->len; ++i) {
 432     VALUE hv = rb_hash_new ();
 433     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
 434     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
 435     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
 436     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
 437     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
 438     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
 439     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
 440     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
 441     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
 442     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
 443     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
 444     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
 445     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
 446     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
 447     rb_ary_push (rv, hv);
 448   }
 449   guestfs_free_lvm_pv_list (r);
 450   return rv;
 451 }
 452
 453 static VALUE ruby_guestfs_test0rpvlisterr (VALUE gv)
 454 {
 455   guestfs_h *g;
 456   Data_Get_Struct (gv, guestfs_h, g);
 457   if (!g)
 458     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rpvlisterr");
 459
 460
 461   struct guestfs_lvm_pv_list *r;
 462
 463   r = guestfs_test0rpvlisterr (g);
 464   if (r == NULL)
 465     rb_raise (e_Error, "%s", guestfs_last_error (g));
 466
 467   VALUE rv = rb_ary_new2 (r->len);
 468   int i;
 469   for (i = 0; i < r->len; ++i) {
 470     VALUE hv = rb_hash_new ();
 471     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
 472     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
 473     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
 474     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
 475     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
 476     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
 477     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
 478     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
 479     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
 480     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
 481     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
 482     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
 483     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
 484     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
 485     rb_ary_push (rv, hv);
 486   }
 487   guestfs_free_lvm_pv_list (r);
 488   return rv;
 489 }
 490
 491 static VALUE ruby_guestfs_test0rvglist (VALUE gv, VALUE valv)
 492 {
 493   guestfs_h *g;
 494   Data_Get_Struct (gv, guestfs_h, g);
 495   if (!g)
 496     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglist");
 497
 498   const char *val = StringValueCStr (valv);
 499   if (!val)
 500     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 501               "val", "test0rvglist");
 502
 503   struct guestfs_lvm_vg_list *r;
 504
 505   r = guestfs_test0rvglist (g, val);
 506   if (r == NULL)
 507     rb_raise (e_Error, "%s", guestfs_last_error (g));
 508
 509   VALUE rv = rb_ary_new2 (r->len);
 510   int i;
 511   for (i = 0; i < r->len; ++i) {
 512     VALUE hv = rb_hash_new ();
 513     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
 514     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
 515     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
 516     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
 517     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
 518     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
 519     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
 520     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
 521     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
 522     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
 523     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
 524     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
 525     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
 526     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
 527     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
 528     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
 529     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
 530     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
 531     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
 532     rb_ary_push (rv, hv);
 533   }
 534   guestfs_free_lvm_vg_list (r);
 535   return rv;
 536 }
 537
 538 static VALUE ruby_guestfs_test0rvglisterr (VALUE gv)
 539 {
 540   guestfs_h *g;
 541   Data_Get_Struct (gv, guestfs_h, g);
 542   if (!g)
 543     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rvglisterr");
 544
 545
 546   struct guestfs_lvm_vg_list *r;
 547
 548   r = guestfs_test0rvglisterr (g);
 549   if (r == NULL)
 550     rb_raise (e_Error, "%s", guestfs_last_error (g));
 551
 552   VALUE rv = rb_ary_new2 (r->len);
 553   int i;
 554   for (i = 0; i < r->len; ++i) {
 555     VALUE hv = rb_hash_new ();
 556     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
 557     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
 558     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
 559     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
 560     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
 561     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
 562     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
 563     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
 564     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
 565     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
 566     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
 567     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
 568     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
 569     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
 570     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
 571     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
 572     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
 573     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
 574     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
 575     rb_ary_push (rv, hv);
 576   }
 577   guestfs_free_lvm_vg_list (r);
 578   return rv;
 579 }
 580
 581 static VALUE ruby_guestfs_test0rlvlist (VALUE gv, VALUE valv)
 582 {
 583   guestfs_h *g;
 584   Data_Get_Struct (gv, guestfs_h, g);
 585   if (!g)
 586     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlist");
 587
 588   const char *val = StringValueCStr (valv);
 589   if (!val)
 590     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 591               "val", "test0rlvlist");
 592
 593   struct guestfs_lvm_lv_list *r;
 594
 595   r = guestfs_test0rlvlist (g, val);
 596   if (r == NULL)
 597     rb_raise (e_Error, "%s", guestfs_last_error (g));
 598
 599   VALUE rv = rb_ary_new2 (r->len);
 600   int i;
 601   for (i = 0; i < r->len; ++i) {
 602     VALUE hv = rb_hash_new ();
 603     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
 604     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
 605     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
 606     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
 607     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
 608     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
 609     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
 610     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
 611     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
 612     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
 613     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
 614     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
 615     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
 616     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
 617     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
 618     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
 619     rb_ary_push (rv, hv);
 620   }
 621   guestfs_free_lvm_lv_list (r);
 622   return rv;
 623 }
 624
 625 static VALUE ruby_guestfs_test0rlvlisterr (VALUE gv)
 626 {
 627   guestfs_h *g;
 628   Data_Get_Struct (gv, guestfs_h, g);
 629   if (!g)
 630     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rlvlisterr");
 631
 632
 633   struct guestfs_lvm_lv_list *r;
 634
 635   r = guestfs_test0rlvlisterr (g);
 636   if (r == NULL)
 637     rb_raise (e_Error, "%s", guestfs_last_error (g));
 638
 639   VALUE rv = rb_ary_new2 (r->len);
 640   int i;
 641   for (i = 0; i < r->len; ++i) {
 642     VALUE hv = rb_hash_new ();
 643     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
 644     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
 645     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
 646     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
 647     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
 648     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
 649     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
 650     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
 651     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
 652     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
 653     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
 654     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
 655     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
 656     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
 657     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
 658     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
 659     rb_ary_push (rv, hv);
 660   }
 661   guestfs_free_lvm_lv_list (r);
 662   return rv;
 663 }
 664
 665 static VALUE ruby_guestfs_test0rstat (VALUE gv, VALUE valv)
 666 {
 667   guestfs_h *g;
 668   Data_Get_Struct (gv, guestfs_h, g);
 669   if (!g)
 670     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstat");
 671
 672   const char *val = StringValueCStr (valv);
 673   if (!val)
 674     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 675               "val", "test0rstat");
 676
 677   struct guestfs_stat *r;
 678
 679   r = guestfs_test0rstat (g, val);
 680   if (r == NULL)
 681     rb_raise (e_Error, "%s", guestfs_last_error (g));
 682
 683   VALUE rv = rb_hash_new ();
 684   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
 685   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
 686   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
 687   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
 688   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
 689   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
 690   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
 691   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
 692   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
 693   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
 694   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
 695   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
 696   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
 697   free (r);
 698   return rv;
 699 }
 700
 701 static VALUE ruby_guestfs_test0rstaterr (VALUE gv)
 702 {
 703   guestfs_h *g;
 704   Data_Get_Struct (gv, guestfs_h, g);
 705   if (!g)
 706     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstaterr");
 707
 708
 709   struct guestfs_stat *r;
 710
 711   r = guestfs_test0rstaterr (g);
 712   if (r == NULL)
 713     rb_raise (e_Error, "%s", guestfs_last_error (g));
 714
 715   VALUE rv = rb_hash_new ();
 716   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
 717   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
 718   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
 719   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
 720   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
 721   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
 722   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
 723   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
 724   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
 725   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
 726   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
 727   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
 728   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
 729   free (r);
 730   return rv;
 731 }
 732
 733 static VALUE ruby_guestfs_test0rstatvfs (VALUE gv, VALUE valv)
 734 {
 735   guestfs_h *g;
 736   Data_Get_Struct (gv, guestfs_h, g);
 737   if (!g)
 738     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfs");
 739
 740   const char *val = StringValueCStr (valv);
 741   if (!val)
 742     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 743               "val", "test0rstatvfs");
 744
 745   struct guestfs_statvfs *r;
 746
 747   r = guestfs_test0rstatvfs (g, val);
 748   if (r == NULL)
 749     rb_raise (e_Error, "%s", guestfs_last_error (g));
 750
 751   VALUE rv = rb_hash_new ();
 752   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
 753   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
 754   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
 755   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
 756   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
 757   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
 758   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
 759   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
 760   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
 761   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
 762   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
 763   free (r);
 764   return rv;
 765 }
 766
 767 static VALUE ruby_guestfs_test0rstatvfserr (VALUE gv)
 768 {
 769   guestfs_h *g;
 770   Data_Get_Struct (gv, guestfs_h, g);
 771   if (!g)
 772     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rstatvfserr");
 773
 774
 775   struct guestfs_statvfs *r;
 776
 777   r = guestfs_test0rstatvfserr (g);
 778   if (r == NULL)
 779     rb_raise (e_Error, "%s", guestfs_last_error (g));
 780
 781   VALUE rv = rb_hash_new ();
 782   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
 783   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
 784   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
 785   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
 786   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
 787   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
 788   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
 789   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
 790   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
 791   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
 792   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
 793   free (r);
 794   return rv;
 795 }
 796
 797 static VALUE ruby_guestfs_test0rhashtable (VALUE gv, VALUE valv)
 798 {
 799   guestfs_h *g;
 800   Data_Get_Struct (gv, guestfs_h, g);
 801   if (!g)
 802     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtable");
 803
 804   const char *val = StringValueCStr (valv);
 805   if (!val)
 806     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 807               "val", "test0rhashtable");
 808
 809   char **r;
 810
 811   r = guestfs_test0rhashtable (g, val);
 812   if (r == NULL)
 813     rb_raise (e_Error, "%s", guestfs_last_error (g));
 814
 815   VALUE rv = rb_hash_new ();
 816   int i;
 817   for (i = 0; r[i] != NULL; i+=2) {
 818     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
 819     free (r[i]);
 820     free (r[i+1]);
 821   }
 822   free (r);
 823   return rv;
 824 }
 825
 826 static VALUE ruby_guestfs_test0rhashtableerr (VALUE gv)
 827 {
 828   guestfs_h *g;
 829   Data_Get_Struct (gv, guestfs_h, g);
 830   if (!g)
 831     rb_raise (rb_eArgError, "%s: used handle after closing it", "test0rhashtableerr");
 832
 833
 834   char **r;
 835
 836   r = guestfs_test0rhashtableerr (g);
 837   if (r == NULL)
 838     rb_raise (e_Error, "%s", guestfs_last_error (g));
 839
 840   VALUE rv = rb_hash_new ();
 841   int i;
 842   for (i = 0; r[i] != NULL; i+=2) {
 843     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
 844     free (r[i]);
 845     free (r[i+1]);
 846   }
 847   free (r);
 848   return rv;
 849 }
 850
 851 static VALUE ruby_guestfs_launch (VALUE gv)
 852 {
 853   guestfs_h *g;
 854   Data_Get_Struct (gv, guestfs_h, g);
 855   if (!g)
 856     rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
 857
 858
 859   int r;
 860
 861   r = guestfs_launch (g);
 862   if (r == -1)
 863     rb_raise (e_Error, "%s", guestfs_last_error (g));
 864
 865   return Qnil;
 866 }
 867
 868 static VALUE ruby_guestfs_wait_ready (VALUE gv)
 869 {
 870   guestfs_h *g;
 871   Data_Get_Struct (gv, guestfs_h, g);
 872   if (!g)
 873     rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
 874
 875
 876   int r;
 877
 878   r = guestfs_wait_ready (g);
 879   if (r == -1)
 880     rb_raise (e_Error, "%s", guestfs_last_error (g));
 881
 882   return Qnil;
 883 }
 884
 885 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
 886 {
 887   guestfs_h *g;
 888   Data_Get_Struct (gv, guestfs_h, g);
 889   if (!g)
 890     rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
 891
 892
 893   int r;
 894
 895   r = guestfs_kill_subprocess (g);
 896   if (r == -1)
 897     rb_raise (e_Error, "%s", guestfs_last_error (g));
 898
 899   return Qnil;
 900 }
 901
 902 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
 903 {
 904   guestfs_h *g;
 905   Data_Get_Struct (gv, guestfs_h, g);
 906   if (!g)
 907     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
 908
 909   const char *filename = StringValueCStr (filenamev);
 910   if (!filename)
 911     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 912               "filename", "add_drive");
 913
 914   int r;
 915
 916   r = guestfs_add_drive (g, filename);
 917   if (r == -1)
 918     rb_raise (e_Error, "%s", guestfs_last_error (g));
 919
 920   return Qnil;
 921 }
 922
 923 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
 924 {
 925   guestfs_h *g;
 926   Data_Get_Struct (gv, guestfs_h, g);
 927   if (!g)
 928     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
 929
 930   const char *filename = StringValueCStr (filenamev);
 931   if (!filename)
 932     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 933               "filename", "add_cdrom");
 934
 935   int r;
 936
 937   r = guestfs_add_cdrom (g, filename);
 938   if (r == -1)
 939     rb_raise (e_Error, "%s", guestfs_last_error (g));
 940
 941   return Qnil;
 942 }
 943
 944 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
 945 {
 946   guestfs_h *g;
 947   Data_Get_Struct (gv, guestfs_h, g);
 948   if (!g)
 949     rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
 950
 951   const char *qemuparam = StringValueCStr (qemuparamv);
 952   if (!qemuparam)
 953     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 954               "qemuparam", "config");
 955   const char *qemuvalue = StringValueCStr (qemuvaluev);
 956
 957   int r;
 958
 959   r = guestfs_config (g, qemuparam, qemuvalue);
 960   if (r == -1)
 961     rb_raise (e_Error, "%s", guestfs_last_error (g));
 962
 963   return Qnil;
 964 }
 965
 966 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
 967 {
 968   guestfs_h *g;
 969   Data_Get_Struct (gv, guestfs_h, g);
 970   if (!g)
 971     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
 972
 973   const char *qemu = StringValueCStr (qemuv);
 974   if (!qemu)
 975     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 976               "qemu", "set_qemu");
 977
 978   int r;
 979
 980   r = guestfs_set_qemu (g, qemu);
 981   if (r == -1)
 982     rb_raise (e_Error, "%s", guestfs_last_error (g));
 983
 984   return Qnil;
 985 }
 986
 987 static VALUE ruby_guestfs_get_qemu (VALUE gv)
 988 {
 989   guestfs_h *g;
 990   Data_Get_Struct (gv, guestfs_h, g);
 991   if (!g)
 992     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
 993
 994
 995   const char *r;
 996
 997   r = guestfs_get_qemu (g);
 998   if (r == NULL)
 999     rb_raise (e_Error, "%s", guestfs_last_error (g));
1000
1001   return rb_str_new2 (r);
1002 }
1003
1004 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
1005 {
1006   guestfs_h *g;
1007   Data_Get_Struct (gv, guestfs_h, g);
1008   if (!g)
1009     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
1010
1011   const char *path = StringValueCStr (pathv);
1012   if (!path)
1013     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1014               "path", "set_path");
1015
1016   int r;
1017
1018   r = guestfs_set_path (g, path);
1019   if (r == -1)
1020     rb_raise (e_Error, "%s", guestfs_last_error (g));
1021
1022   return Qnil;
1023 }
1024
1025 static VALUE ruby_guestfs_get_path (VALUE gv)
1026 {
1027   guestfs_h *g;
1028   Data_Get_Struct (gv, guestfs_h, g);
1029   if (!g)
1030     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
1031
1032
1033   const char *r;
1034
1035   r = guestfs_get_path (g);
1036   if (r == NULL)
1037     rb_raise (e_Error, "%s", guestfs_last_error (g));
1038
1039   return rb_str_new2 (r);
1040 }
1041
1042 static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
1043 {
1044   guestfs_h *g;
1045   Data_Get_Struct (gv, guestfs_h, g);
1046   if (!g)
1047     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_append");
1048
1049   const char *append = StringValueCStr (appendv);
1050   if (!append)
1051     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1052               "append", "set_append");
1053
1054   int r;
1055
1056   r = guestfs_set_append (g, append);
1057   if (r == -1)
1058     rb_raise (e_Error, "%s", guestfs_last_error (g));
1059
1060   return Qnil;
1061 }
1062
1063 static VALUE ruby_guestfs_get_append (VALUE gv)
1064 {
1065   guestfs_h *g;
1066   Data_Get_Struct (gv, guestfs_h, g);
1067   if (!g)
1068     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append");
1069
1070
1071   const char *r;
1072
1073   r = guestfs_get_append (g);
1074   if (r == NULL)
1075     rb_raise (e_Error, "%s", guestfs_last_error (g));
1076
1077   return rb_str_new2 (r);
1078 }
1079
1080 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
1081 {
1082   guestfs_h *g;
1083   Data_Get_Struct (gv, guestfs_h, g);
1084   if (!g)
1085     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
1086
1087   int autosync = NUM2INT (autosyncv);
1088
1089   int r;
1090
1091   r = guestfs_set_autosync (g, autosync);
1092   if (r == -1)
1093     rb_raise (e_Error, "%s", guestfs_last_error (g));
1094
1095   return Qnil;
1096 }
1097
1098 static VALUE ruby_guestfs_get_autosync (VALUE gv)
1099 {
1100   guestfs_h *g;
1101   Data_Get_Struct (gv, guestfs_h, g);
1102   if (!g)
1103     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
1104
1105
1106   int r;
1107
1108   r = guestfs_get_autosync (g);
1109   if (r == -1)
1110     rb_raise (e_Error, "%s", guestfs_last_error (g));
1111
1112   return INT2NUM (r);
1113 }
1114
1115 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
1116 {
1117   guestfs_h *g;
1118   Data_Get_Struct (gv, guestfs_h, g);
1119   if (!g)
1120     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
1121
1122   int verbose = NUM2INT (verbosev);
1123
1124   int r;
1125
1126   r = guestfs_set_verbose (g, verbose);
1127   if (r == -1)
1128     rb_raise (e_Error, "%s", guestfs_last_error (g));
1129
1130   return Qnil;
1131 }
1132
1133 static VALUE ruby_guestfs_get_verbose (VALUE gv)
1134 {
1135   guestfs_h *g;
1136   Data_Get_Struct (gv, guestfs_h, g);
1137   if (!g)
1138     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
1139
1140
1141   int r;
1142
1143   r = guestfs_get_verbose (g);
1144   if (r == -1)
1145     rb_raise (e_Error, "%s", guestfs_last_error (g));
1146
1147   return INT2NUM (r);
1148 }
1149
1150 static VALUE ruby_guestfs_is_ready (VALUE gv)
1151 {
1152   guestfs_h *g;
1153   Data_Get_Struct (gv, guestfs_h, g);
1154   if (!g)
1155     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
1156
1157
1158   int r;
1159
1160   r = guestfs_is_ready (g);
1161   if (r == -1)
1162     rb_raise (e_Error, "%s", guestfs_last_error (g));
1163
1164   return INT2NUM (r);
1165 }
1166
1167 static VALUE ruby_guestfs_is_config (VALUE gv)
1168 {
1169   guestfs_h *g;
1170   Data_Get_Struct (gv, guestfs_h, g);
1171   if (!g)
1172     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
1173
1174
1175   int r;
1176
1177   r = guestfs_is_config (g);
1178   if (r == -1)
1179     rb_raise (e_Error, "%s", guestfs_last_error (g));
1180
1181   return INT2NUM (r);
1182 }
1183
1184 static VALUE ruby_guestfs_is_launching (VALUE gv)
1185 {
1186   guestfs_h *g;
1187   Data_Get_Struct (gv, guestfs_h, g);
1188   if (!g)
1189     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
1190
1191
1192   int r;
1193
1194   r = guestfs_is_launching (g);
1195   if (r == -1)
1196     rb_raise (e_Error, "%s", guestfs_last_error (g));
1197
1198   return INT2NUM (r);
1199 }
1200
1201 static VALUE ruby_guestfs_is_busy (VALUE gv)
1202 {
1203   guestfs_h *g;
1204   Data_Get_Struct (gv, guestfs_h, g);
1205   if (!g)
1206     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
1207
1208
1209   int r;
1210
1211   r = guestfs_is_busy (g);
1212   if (r == -1)
1213     rb_raise (e_Error, "%s", guestfs_last_error (g));
1214
1215   return INT2NUM (r);
1216 }
1217
1218 static VALUE ruby_guestfs_get_state (VALUE gv)
1219 {
1220   guestfs_h *g;
1221   Data_Get_Struct (gv, guestfs_h, g);
1222   if (!g)
1223     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
1224
1225
1226   int r;
1227
1228   r = guestfs_get_state (g);
1229   if (r == -1)
1230     rb_raise (e_Error, "%s", guestfs_last_error (g));
1231
1232   return INT2NUM (r);
1233 }
1234
1235 static VALUE ruby_guestfs_set_busy (VALUE gv)
1236 {
1237   guestfs_h *g;
1238   Data_Get_Struct (gv, guestfs_h, g);
1239   if (!g)
1240     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
1241
1242
1243   int r;
1244
1245   r = guestfs_set_busy (g);
1246   if (r == -1)
1247     rb_raise (e_Error, "%s", guestfs_last_error (g));
1248
1249   return Qnil;
1250 }
1251
1252 static VALUE ruby_guestfs_set_ready (VALUE gv)
1253 {
1254   guestfs_h *g;
1255   Data_Get_Struct (gv, guestfs_h, g);
1256   if (!g)
1257     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
1258
1259
1260   int r;
1261
1262   r = guestfs_set_ready (g);
1263   if (r == -1)
1264     rb_raise (e_Error, "%s", guestfs_last_error (g));
1265
1266   return Qnil;
1267 }
1268
1269 static VALUE ruby_guestfs_end_busy (VALUE gv)
1270 {
1271   guestfs_h *g;
1272   Data_Get_Struct (gv, guestfs_h, g);
1273   if (!g)
1274     rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
1275
1276
1277   int r;
1278
1279   r = guestfs_end_busy (g);
1280   if (r == -1)
1281     rb_raise (e_Error, "%s", guestfs_last_error (g));
1282
1283   return Qnil;
1284 }
1285
1286 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
1287 {
1288   guestfs_h *g;
1289   Data_Get_Struct (gv, guestfs_h, g);
1290   if (!g)
1291     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
1292
1293   const char *device = StringValueCStr (devicev);
1294   if (!device)
1295     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1296               "device", "mount");
1297   const char *mountpoint = StringValueCStr (mountpointv);
1298   if (!mountpoint)
1299     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1300               "mountpoint", "mount");
1301
1302   int r;
1303
1304   r = guestfs_mount (g, device, mountpoint);
1305   if (r == -1)
1306     rb_raise (e_Error, "%s", guestfs_last_error (g));
1307
1308   return Qnil;
1309 }
1310
1311 static VALUE ruby_guestfs_sync (VALUE gv)
1312 {
1313   guestfs_h *g;
1314   Data_Get_Struct (gv, guestfs_h, g);
1315   if (!g)
1316     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
1317
1318
1319   int r;
1320
1321   r = guestfs_sync (g);
1322   if (r == -1)
1323     rb_raise (e_Error, "%s", guestfs_last_error (g));
1324
1325   return Qnil;
1326 }
1327
1328 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
1329 {
1330   guestfs_h *g;
1331   Data_Get_Struct (gv, guestfs_h, g);
1332   if (!g)
1333     rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
1334
1335   const char *path = StringValueCStr (pathv);
1336   if (!path)
1337     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1338               "path", "touch");
1339
1340   int r;
1341
1342   r = guestfs_touch (g, path);
1343   if (r == -1)
1344     rb_raise (e_Error, "%s", guestfs_last_error (g));
1345
1346   return Qnil;
1347 }
1348
1349 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
1350 {
1351   guestfs_h *g;
1352   Data_Get_Struct (gv, guestfs_h, g);
1353   if (!g)
1354     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
1355
1356   const char *path = StringValueCStr (pathv);
1357   if (!path)
1358     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1359               "path", "cat");
1360
1361   char *r;
1362
1363   r = guestfs_cat (g, path);
1364   if (r == NULL)
1365     rb_raise (e_Error, "%s", guestfs_last_error (g));
1366
1367   VALUE rv = rb_str_new2 (r);
1368   free (r);
1369   return rv;
1370 }
1371
1372 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
1373 {
1374   guestfs_h *g;
1375   Data_Get_Struct (gv, guestfs_h, g);
1376   if (!g)
1377     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
1378
1379   const char *directory = StringValueCStr (directoryv);
1380   if (!directory)
1381     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1382               "directory", "ll");
1383
1384   char *r;
1385
1386   r = guestfs_ll (g, directory);
1387   if (r == NULL)
1388     rb_raise (e_Error, "%s", guestfs_last_error (g));
1389
1390   VALUE rv = rb_str_new2 (r);
1391   free (r);
1392   return rv;
1393 }
1394
1395 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
1396 {
1397   guestfs_h *g;
1398   Data_Get_Struct (gv, guestfs_h, g);
1399   if (!g)
1400     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
1401
1402   const char *directory = StringValueCStr (directoryv);
1403   if (!directory)
1404     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1405               "directory", "ls");
1406
1407   char **r;
1408
1409   r = guestfs_ls (g, directory);
1410   if (r == NULL)
1411     rb_raise (e_Error, "%s", guestfs_last_error (g));
1412
1413   int i, len = 0;
1414   for (i = 0; r[i] != NULL; ++i) len++;
1415   VALUE rv = rb_ary_new2 (len);
1416   for (i = 0; r[i] != NULL; ++i) {
1417     rb_ary_push (rv, rb_str_new2 (r[i]));
1418     free (r[i]);
1419   }
1420   free (r);
1421   return rv;
1422 }
1423
1424 static VALUE ruby_guestfs_list_devices (VALUE gv)
1425 {
1426   guestfs_h *g;
1427   Data_Get_Struct (gv, guestfs_h, g);
1428   if (!g)
1429     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
1430
1431
1432   char **r;
1433
1434   r = guestfs_list_devices (g);
1435   if (r == NULL)
1436     rb_raise (e_Error, "%s", guestfs_last_error (g));
1437
1438   int i, len = 0;
1439   for (i = 0; r[i] != NULL; ++i) len++;
1440   VALUE rv = rb_ary_new2 (len);
1441   for (i = 0; r[i] != NULL; ++i) {
1442     rb_ary_push (rv, rb_str_new2 (r[i]));
1443     free (r[i]);
1444   }
1445   free (r);
1446   return rv;
1447 }
1448
1449 static VALUE ruby_guestfs_list_partitions (VALUE gv)
1450 {
1451   guestfs_h *g;
1452   Data_Get_Struct (gv, guestfs_h, g);
1453   if (!g)
1454     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
1455
1456
1457   char **r;
1458
1459   r = guestfs_list_partitions (g);
1460   if (r == NULL)
1461     rb_raise (e_Error, "%s", guestfs_last_error (g));
1462
1463   int i, len = 0;
1464   for (i = 0; r[i] != NULL; ++i) len++;
1465   VALUE rv = rb_ary_new2 (len);
1466   for (i = 0; r[i] != NULL; ++i) {
1467     rb_ary_push (rv, rb_str_new2 (r[i]));
1468     free (r[i]);
1469   }
1470   free (r);
1471   return rv;
1472 }
1473
1474 static VALUE ruby_guestfs_pvs (VALUE gv)
1475 {
1476   guestfs_h *g;
1477   Data_Get_Struct (gv, guestfs_h, g);
1478   if (!g)
1479     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
1480
1481
1482   char **r;
1483
1484   r = guestfs_pvs (g);
1485   if (r == NULL)
1486     rb_raise (e_Error, "%s", guestfs_last_error (g));
1487
1488   int i, len = 0;
1489   for (i = 0; r[i] != NULL; ++i) len++;
1490   VALUE rv = rb_ary_new2 (len);
1491   for (i = 0; r[i] != NULL; ++i) {
1492     rb_ary_push (rv, rb_str_new2 (r[i]));
1493     free (r[i]);
1494   }
1495   free (r);
1496   return rv;
1497 }
1498
1499 static VALUE ruby_guestfs_vgs (VALUE gv)
1500 {
1501   guestfs_h *g;
1502   Data_Get_Struct (gv, guestfs_h, g);
1503   if (!g)
1504     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
1505
1506
1507   char **r;
1508
1509   r = guestfs_vgs (g);
1510   if (r == NULL)
1511     rb_raise (e_Error, "%s", guestfs_last_error (g));
1512
1513   int i, len = 0;
1514   for (i = 0; r[i] != NULL; ++i) len++;
1515   VALUE rv = rb_ary_new2 (len);
1516   for (i = 0; r[i] != NULL; ++i) {
1517     rb_ary_push (rv, rb_str_new2 (r[i]));
1518     free (r[i]);
1519   }
1520   free (r);
1521   return rv;
1522 }
1523
1524 static VALUE ruby_guestfs_lvs (VALUE gv)
1525 {
1526   guestfs_h *g;
1527   Data_Get_Struct (gv, guestfs_h, g);
1528   if (!g)
1529     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
1530
1531
1532   char **r;
1533
1534   r = guestfs_lvs (g);
1535   if (r == NULL)
1536     rb_raise (e_Error, "%s", guestfs_last_error (g));
1537
1538   int i, len = 0;
1539   for (i = 0; r[i] != NULL; ++i) len++;
1540   VALUE rv = rb_ary_new2 (len);
1541   for (i = 0; r[i] != NULL; ++i) {
1542     rb_ary_push (rv, rb_str_new2 (r[i]));
1543     free (r[i]);
1544   }
1545   free (r);
1546   return rv;
1547 }
1548
1549 static VALUE ruby_guestfs_pvs_full (VALUE gv)
1550 {
1551   guestfs_h *g;
1552   Data_Get_Struct (gv, guestfs_h, g);
1553   if (!g)
1554     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
1555
1556
1557   struct guestfs_lvm_pv_list *r;
1558
1559   r = guestfs_pvs_full (g);
1560   if (r == NULL)
1561     rb_raise (e_Error, "%s", guestfs_last_error (g));
1562
1563   VALUE rv = rb_ary_new2 (r->len);
1564   int i;
1565   for (i = 0; i < r->len; ++i) {
1566     VALUE hv = rb_hash_new ();
1567     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
1568     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
1569     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
1570     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
1571     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
1572     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
1573     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
1574     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
1575     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
1576     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
1577     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
1578     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
1579     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
1580     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
1581     rb_ary_push (rv, hv);
1582   }
1583   guestfs_free_lvm_pv_list (r);
1584   return rv;
1585 }
1586
1587 static VALUE ruby_guestfs_vgs_full (VALUE gv)
1588 {
1589   guestfs_h *g;
1590   Data_Get_Struct (gv, guestfs_h, g);
1591   if (!g)
1592     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
1593
1594
1595   struct guestfs_lvm_vg_list *r;
1596
1597   r = guestfs_vgs_full (g);
1598   if (r == NULL)
1599     rb_raise (e_Error, "%s", guestfs_last_error (g));
1600
1601   VALUE rv = rb_ary_new2 (r->len);
1602   int i;
1603   for (i = 0; i < r->len; ++i) {
1604     VALUE hv = rb_hash_new ();
1605     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
1606     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
1607     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
1608     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
1609     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
1610     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
1611     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
1612     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
1613     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
1614     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
1615     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
1616     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
1617     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
1618     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
1619     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
1620     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
1621     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
1622     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
1623     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
1624     rb_ary_push (rv, hv);
1625   }
1626   guestfs_free_lvm_vg_list (r);
1627   return rv;
1628 }
1629
1630 static VALUE ruby_guestfs_lvs_full (VALUE gv)
1631 {
1632   guestfs_h *g;
1633   Data_Get_Struct (gv, guestfs_h, g);
1634   if (!g)
1635     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
1636
1637
1638   struct guestfs_lvm_lv_list *r;
1639
1640   r = guestfs_lvs_full (g);
1641   if (r == NULL)
1642     rb_raise (e_Error, "%s", guestfs_last_error (g));
1643
1644   VALUE rv = rb_ary_new2 (r->len);
1645   int i;
1646   for (i = 0; i < r->len; ++i) {
1647     VALUE hv = rb_hash_new ();
1648     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
1649     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
1650     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
1651     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
1652     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
1653     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
1654     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
1655     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
1656     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
1657     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
1658     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
1659     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
1660     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
1661     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
1662     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
1663     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
1664     rb_ary_push (rv, hv);
1665   }
1666   guestfs_free_lvm_lv_list (r);
1667   return rv;
1668 }
1669
1670 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
1671 {
1672   guestfs_h *g;
1673   Data_Get_Struct (gv, guestfs_h, g);
1674   if (!g)
1675     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
1676
1677   const char *path = StringValueCStr (pathv);
1678   if (!path)
1679     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1680               "path", "read_lines");
1681
1682   char **r;
1683
1684   r = guestfs_read_lines (g, path);
1685   if (r == NULL)
1686     rb_raise (e_Error, "%s", guestfs_last_error (g));
1687
1688   int i, len = 0;
1689   for (i = 0; r[i] != NULL; ++i) len++;
1690   VALUE rv = rb_ary_new2 (len);
1691   for (i = 0; r[i] != NULL; ++i) {
1692     rb_ary_push (rv, rb_str_new2 (r[i]));
1693     free (r[i]);
1694   }
1695   free (r);
1696   return rv;
1697 }
1698
1699 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
1700 {
1701   guestfs_h *g;
1702   Data_Get_Struct (gv, guestfs_h, g);
1703   if (!g)
1704     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
1705
1706   const char *root = StringValueCStr (rootv);
1707   if (!root)
1708     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1709               "root", "aug_init");
1710   int flags = NUM2INT (flagsv);
1711
1712   int r;
1713
1714   r = guestfs_aug_init (g, root, flags);
1715   if (r == -1)
1716     rb_raise (e_Error, "%s", guestfs_last_error (g));
1717
1718   return Qnil;
1719 }
1720
1721 static VALUE ruby_guestfs_aug_close (VALUE gv)
1722 {
1723   guestfs_h *g;
1724   Data_Get_Struct (gv, guestfs_h, g);
1725   if (!g)
1726     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
1727
1728
1729   int r;
1730
1731   r = guestfs_aug_close (g);
1732   if (r == -1)
1733     rb_raise (e_Error, "%s", guestfs_last_error (g));
1734
1735   return Qnil;
1736 }
1737
1738 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
1739 {
1740   guestfs_h *g;
1741   Data_Get_Struct (gv, guestfs_h, g);
1742   if (!g)
1743     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
1744
1745   const char *name = StringValueCStr (namev);
1746   if (!name)
1747     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1748               "name", "aug_defvar");
1749   const char *expr = StringValueCStr (exprv);
1750
1751   int r;
1752
1753   r = guestfs_aug_defvar (g, name, expr);
1754   if (r == -1)
1755     rb_raise (e_Error, "%s", guestfs_last_error (g));
1756
1757   return INT2NUM (r);
1758 }
1759
1760 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
1761 {
1762   guestfs_h *g;
1763   Data_Get_Struct (gv, guestfs_h, g);
1764   if (!g)
1765     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
1766
1767   const char *name = StringValueCStr (namev);
1768   if (!name)
1769     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1770               "name", "aug_defnode");
1771   const char *expr = StringValueCStr (exprv);
1772   if (!expr)
1773     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1774               "expr", "aug_defnode");
1775   const char *val = StringValueCStr (valv);
1776   if (!val)
1777     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1778               "val", "aug_defnode");
1779
1780   struct guestfs_int_bool *r;
1781
1782   r = guestfs_aug_defnode (g, name, expr, val);
1783   if (r == NULL)
1784     rb_raise (e_Error, "%s", guestfs_last_error (g));
1785
1786   VALUE rv = rb_ary_new2 (2);
1787   rb_ary_push (rv, INT2NUM (r->i));
1788   rb_ary_push (rv, INT2NUM (r->b));
1789   guestfs_free_int_bool (r);
1790   return rv;
1791 }
1792
1793 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1794 {
1795   guestfs_h *g;
1796   Data_Get_Struct (gv, guestfs_h, g);
1797   if (!g)
1798     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1799
1800   const char *path = StringValueCStr (pathv);
1801   if (!path)
1802     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1803               "path", "aug_get");
1804
1805   char *r;
1806
1807   r = guestfs_aug_get (g, path);
1808   if (r == NULL)
1809     rb_raise (e_Error, "%s", guestfs_last_error (g));
1810
1811   VALUE rv = rb_str_new2 (r);
1812   free (r);
1813   return rv;
1814 }
1815
1816 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1817 {
1818   guestfs_h *g;
1819   Data_Get_Struct (gv, guestfs_h, g);
1820   if (!g)
1821     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1822
1823   const char *path = StringValueCStr (pathv);
1824   if (!path)
1825     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1826               "path", "aug_set");
1827   const char *val = StringValueCStr (valv);
1828   if (!val)
1829     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1830               "val", "aug_set");
1831
1832   int r;
1833
1834   r = guestfs_aug_set (g, path, val);
1835   if (r == -1)
1836     rb_raise (e_Error, "%s", guestfs_last_error (g));
1837
1838   return Qnil;
1839 }
1840
1841 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1842 {
1843   guestfs_h *g;
1844   Data_Get_Struct (gv, guestfs_h, g);
1845   if (!g)
1846     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1847
1848   const char *path = StringValueCStr (pathv);
1849   if (!path)
1850     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1851               "path", "aug_insert");
1852   const char *label = StringValueCStr (labelv);
1853   if (!label)
1854     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1855               "label", "aug_insert");
1856   int before = NUM2INT (beforev);
1857
1858   int r;
1859
1860   r = guestfs_aug_insert (g, path, label, before);
1861   if (r == -1)
1862     rb_raise (e_Error, "%s", guestfs_last_error (g));
1863
1864   return Qnil;
1865 }
1866
1867 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1868 {
1869   guestfs_h *g;
1870   Data_Get_Struct (gv, guestfs_h, g);
1871   if (!g)
1872     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1873
1874   const char *path = StringValueCStr (pathv);
1875   if (!path)
1876     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1877               "path", "aug_rm");
1878
1879   int r;
1880
1881   r = guestfs_aug_rm (g, path);
1882   if (r == -1)
1883     rb_raise (e_Error, "%s", guestfs_last_error (g));
1884
1885   return INT2NUM (r);
1886 }
1887
1888 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1889 {
1890   guestfs_h *g;
1891   Data_Get_Struct (gv, guestfs_h, g);
1892   if (!g)
1893     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1894
1895   const char *src = StringValueCStr (srcv);
1896   if (!src)
1897     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1898               "src", "aug_mv");
1899   const char *dest = StringValueCStr (destv);
1900   if (!dest)
1901     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1902               "dest", "aug_mv");
1903
1904   int r;
1905
1906   r = guestfs_aug_mv (g, src, dest);
1907   if (r == -1)
1908     rb_raise (e_Error, "%s", guestfs_last_error (g));
1909
1910   return Qnil;
1911 }
1912
1913 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1914 {
1915   guestfs_h *g;
1916   Data_Get_Struct (gv, guestfs_h, g);
1917   if (!g)
1918     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1919
1920   const char *path = StringValueCStr (pathv);
1921   if (!path)
1922     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1923               "path", "aug_match");
1924
1925   char **r;
1926
1927   r = guestfs_aug_match (g, path);
1928   if (r == NULL)
1929     rb_raise (e_Error, "%s", guestfs_last_error (g));
1930
1931   int i, len = 0;
1932   for (i = 0; r[i] != NULL; ++i) len++;
1933   VALUE rv = rb_ary_new2 (len);
1934   for (i = 0; r[i] != NULL; ++i) {
1935     rb_ary_push (rv, rb_str_new2 (r[i]));
1936     free (r[i]);
1937   }
1938   free (r);
1939   return rv;
1940 }
1941
1942 static VALUE ruby_guestfs_aug_save (VALUE gv)
1943 {
1944   guestfs_h *g;
1945   Data_Get_Struct (gv, guestfs_h, g);
1946   if (!g)
1947     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1948
1949
1950   int r;
1951
1952   r = guestfs_aug_save (g);
1953   if (r == -1)
1954     rb_raise (e_Error, "%s", guestfs_last_error (g));
1955
1956   return Qnil;
1957 }
1958
1959 static VALUE ruby_guestfs_aug_load (VALUE gv)
1960 {
1961   guestfs_h *g;
1962   Data_Get_Struct (gv, guestfs_h, g);
1963   if (!g)
1964     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1965
1966
1967   int r;
1968
1969   r = guestfs_aug_load (g);
1970   if (r == -1)
1971     rb_raise (e_Error, "%s", guestfs_last_error (g));
1972
1973   return Qnil;
1974 }
1975
1976 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1977 {
1978   guestfs_h *g;
1979   Data_Get_Struct (gv, guestfs_h, g);
1980   if (!g)
1981     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
1982
1983   const char *path = StringValueCStr (pathv);
1984   if (!path)
1985     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1986               "path", "aug_ls");
1987
1988   char **r;
1989
1990   r = guestfs_aug_ls (g, path);
1991   if (r == NULL)
1992     rb_raise (e_Error, "%s", guestfs_last_error (g));
1993
1994   int i, len = 0;
1995   for (i = 0; r[i] != NULL; ++i) len++;
1996   VALUE rv = rb_ary_new2 (len);
1997   for (i = 0; r[i] != NULL; ++i) {
1998     rb_ary_push (rv, rb_str_new2 (r[i]));
1999     free (r[i]);
2000   }
2001   free (r);
2002   return rv;
2003 }
2004
2005 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
2006 {
2007   guestfs_h *g;
2008   Data_Get_Struct (gv, guestfs_h, g);
2009   if (!g)
2010     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
2011
2012   const char *path = StringValueCStr (pathv);
2013   if (!path)
2014     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2015               "path", "rm");
2016
2017   int r;
2018
2019   r = guestfs_rm (g, path);
2020   if (r == -1)
2021     rb_raise (e_Error, "%s", guestfs_last_error (g));
2022
2023   return Qnil;
2024 }
2025
2026 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
2027 {
2028   guestfs_h *g;
2029   Data_Get_Struct (gv, guestfs_h, g);
2030   if (!g)
2031     rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
2032
2033   const char *path = StringValueCStr (pathv);
2034   if (!path)
2035     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2036               "path", "rmdir");
2037
2038   int r;
2039
2040   r = guestfs_rmdir (g, path);
2041   if (r == -1)
2042     rb_raise (e_Error, "%s", guestfs_last_error (g));
2043
2044   return Qnil;
2045 }
2046
2047 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
2048 {
2049   guestfs_h *g;
2050   Data_Get_Struct (gv, guestfs_h, g);
2051   if (!g)
2052     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
2053
2054   const char *path = StringValueCStr (pathv);
2055   if (!path)
2056     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2057               "path", "rm_rf");
2058
2059   int r;
2060
2061   r = guestfs_rm_rf (g, path);
2062   if (r == -1)
2063     rb_raise (e_Error, "%s", guestfs_last_error (g));
2064
2065   return Qnil;
2066 }
2067
2068 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
2069 {
2070   guestfs_h *g;
2071   Data_Get_Struct (gv, guestfs_h, g);
2072   if (!g)
2073     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
2074
2075   const char *path = StringValueCStr (pathv);
2076   if (!path)
2077     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2078               "path", "mkdir");
2079
2080   int r;
2081
2082   r = guestfs_mkdir (g, path);
2083   if (r == -1)
2084     rb_raise (e_Error, "%s", guestfs_last_error (g));
2085
2086   return Qnil;
2087 }
2088
2089 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
2090 {
2091   guestfs_h *g;
2092   Data_Get_Struct (gv, guestfs_h, g);
2093   if (!g)
2094     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
2095
2096   const char *path = StringValueCStr (pathv);
2097   if (!path)
2098     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2099               "path", "mkdir_p");
2100
2101   int r;
2102
2103   r = guestfs_mkdir_p (g, path);
2104   if (r == -1)
2105     rb_raise (e_Error, "%s", guestfs_last_error (g));
2106
2107   return Qnil;
2108 }
2109
2110 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
2111 {
2112   guestfs_h *g;
2113   Data_Get_Struct (gv, guestfs_h, g);
2114   if (!g)
2115     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
2116
2117   int mode = NUM2INT (modev);
2118   const char *path = StringValueCStr (pathv);
2119   if (!path)
2120     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2121               "path", "chmod");
2122
2123   int r;
2124
2125   r = guestfs_chmod (g, mode, path);
2126   if (r == -1)
2127     rb_raise (e_Error, "%s", guestfs_last_error (g));
2128
2129   return Qnil;
2130 }
2131
2132 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
2133 {
2134   guestfs_h *g;
2135   Data_Get_Struct (gv, guestfs_h, g);
2136   if (!g)
2137     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
2138
2139   int owner = NUM2INT (ownerv);
2140   int group = NUM2INT (groupv);
2141   const char *path = StringValueCStr (pathv);
2142   if (!path)
2143     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2144               "path", "chown");
2145
2146   int r;
2147
2148   r = guestfs_chown (g, owner, group, path);
2149   if (r == -1)
2150     rb_raise (e_Error, "%s", guestfs_last_error (g));
2151
2152   return Qnil;
2153 }
2154
2155 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
2156 {
2157   guestfs_h *g;
2158   Data_Get_Struct (gv, guestfs_h, g);
2159   if (!g)
2160     rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
2161
2162   const char *path = StringValueCStr (pathv);
2163   if (!path)
2164     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2165               "path", "exists");
2166
2167   int r;
2168
2169   r = guestfs_exists (g, path);
2170   if (r == -1)
2171     rb_raise (e_Error, "%s", guestfs_last_error (g));
2172
2173   return INT2NUM (r);
2174 }
2175
2176 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
2177 {
2178   guestfs_h *g;
2179   Data_Get_Struct (gv, guestfs_h, g);
2180   if (!g)
2181     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
2182
2183   const char *path = StringValueCStr (pathv);
2184   if (!path)
2185     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2186               "path", "is_file");
2187
2188   int r;
2189
2190   r = guestfs_is_file (g, path);
2191   if (r == -1)
2192     rb_raise (e_Error, "%s", guestfs_last_error (g));
2193
2194   return INT2NUM (r);
2195 }
2196
2197 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
2198 {
2199   guestfs_h *g;
2200   Data_Get_Struct (gv, guestfs_h, g);
2201   if (!g)
2202     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
2203
2204   const char *path = StringValueCStr (pathv);
2205   if (!path)
2206     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2207               "path", "is_dir");
2208
2209   int r;
2210
2211   r = guestfs_is_dir (g, path);
2212   if (r == -1)
2213     rb_raise (e_Error, "%s", guestfs_last_error (g));
2214
2215   return INT2NUM (r);
2216 }
2217
2218 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
2219 {
2220   guestfs_h *g;
2221   Data_Get_Struct (gv, guestfs_h, g);
2222   if (!g)
2223     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
2224
2225   const char *device = StringValueCStr (devicev);
2226   if (!device)
2227     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2228               "device", "pvcreate");
2229
2230   int r;
2231
2232   r = guestfs_pvcreate (g, device);
2233   if (r == -1)
2234     rb_raise (e_Error, "%s", guestfs_last_error (g));
2235
2236   return Qnil;
2237 }
2238
2239 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
2240 {
2241   guestfs_h *g;
2242   Data_Get_Struct (gv, guestfs_h, g);
2243   if (!g)
2244     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
2245
2246   const char *volgroup = StringValueCStr (volgroupv);
2247   if (!volgroup)
2248     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2249               "volgroup", "vgcreate");
2250   char **physvols;  {
2251     int i, len;
2252     len = RARRAY_LEN (physvolsv);
2253     physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2254     for (i = 0; i < len; ++i) {
2255       VALUE v = rb_ary_entry (physvolsv, i);
2256       physvols[i] = StringValueCStr (v);
2257     }
2258     physvols[len] = NULL;
2259   }
2260
2261   int r;
2262
2263   r = guestfs_vgcreate (g, volgroup, physvols);
2264   free (physvols);
2265   if (r == -1)
2266     rb_raise (e_Error, "%s", guestfs_last_error (g));
2267
2268   return Qnil;
2269 }
2270
2271 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
2272 {
2273   guestfs_h *g;
2274   Data_Get_Struct (gv, guestfs_h, g);
2275   if (!g)
2276     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
2277
2278   const char *logvol = StringValueCStr (logvolv);
2279   if (!logvol)
2280     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2281               "logvol", "lvcreate");
2282   const char *volgroup = StringValueCStr (volgroupv);
2283   if (!volgroup)
2284     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2285               "volgroup", "lvcreate");
2286   int mbytes = NUM2INT (mbytesv);
2287
2288   int r;
2289
2290   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2291   if (r == -1)
2292     rb_raise (e_Error, "%s", guestfs_last_error (g));
2293
2294   return Qnil;
2295 }
2296
2297 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
2298 {
2299   guestfs_h *g;
2300   Data_Get_Struct (gv, guestfs_h, g);
2301   if (!g)
2302     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
2303
2304   const char *fstype = StringValueCStr (fstypev);
2305   if (!fstype)
2306     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2307               "fstype", "mkfs");
2308   const char *device = StringValueCStr (devicev);
2309   if (!device)
2310     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2311               "device", "mkfs");
2312
2313   int r;
2314
2315   r = guestfs_mkfs (g, fstype, device);
2316   if (r == -1)
2317     rb_raise (e_Error, "%s", guestfs_last_error (g));
2318
2319   return Qnil;
2320 }
2321
2322 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
2323 {
2324   guestfs_h *g;
2325   Data_Get_Struct (gv, guestfs_h, g);
2326   if (!g)
2327     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
2328
2329   const char *device = StringValueCStr (devicev);
2330   if (!device)
2331     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2332               "device", "sfdisk");
2333   int cyls = NUM2INT (cylsv);
2334   int heads = NUM2INT (headsv);
2335   int sectors = NUM2INT (sectorsv);
2336   char **lines;  {
2337     int i, len;
2338     len = RARRAY_LEN (linesv);
2339     lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2340     for (i = 0; i < len; ++i) {
2341       VALUE v = rb_ary_entry (linesv, i);
2342       lines[i] = StringValueCStr (v);
2343     }
2344     lines[len] = NULL;
2345   }
2346
2347   int r;
2348
2349   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2350   free (lines);
2351   if (r == -1)
2352     rb_raise (e_Error, "%s", guestfs_last_error (g));
2353
2354   return Qnil;
2355 }
2356
2357 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
2358 {
2359   guestfs_h *g;
2360   Data_Get_Struct (gv, guestfs_h, g);
2361   if (!g)
2362     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
2363
2364   const char *path = StringValueCStr (pathv);
2365   if (!path)
2366     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2367               "path", "write_file");
2368   const char *content = StringValueCStr (contentv);
2369   if (!content)
2370     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2371               "content", "write_file");
2372   int size = NUM2INT (sizev);
2373
2374   int r;
2375
2376   r = guestfs_write_file (g, path, content, size);
2377   if (r == -1)
2378     rb_raise (e_Error, "%s", guestfs_last_error (g));
2379
2380   return Qnil;
2381 }
2382
2383 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
2384 {
2385   guestfs_h *g;
2386   Data_Get_Struct (gv, guestfs_h, g);
2387   if (!g)
2388     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
2389
2390   const char *pathordevice = StringValueCStr (pathordevicev);
2391   if (!pathordevice)
2392     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2393               "pathordevice", "umount");
2394
2395   int r;
2396
2397   r = guestfs_umount (g, pathordevice);
2398   if (r == -1)
2399     rb_raise (e_Error, "%s", guestfs_last_error (g));
2400
2401   return Qnil;
2402 }
2403
2404 static VALUE ruby_guestfs_mounts (VALUE gv)
2405 {
2406   guestfs_h *g;
2407   Data_Get_Struct (gv, guestfs_h, g);
2408   if (!g)
2409     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
2410
2411
2412   char **r;
2413
2414   r = guestfs_mounts (g);
2415   if (r == NULL)
2416     rb_raise (e_Error, "%s", guestfs_last_error (g));
2417
2418   int i, len = 0;
2419   for (i = 0; r[i] != NULL; ++i) len++;
2420   VALUE rv = rb_ary_new2 (len);
2421   for (i = 0; r[i] != NULL; ++i) {
2422     rb_ary_push (rv, rb_str_new2 (r[i]));
2423     free (r[i]);
2424   }
2425   free (r);
2426   return rv;
2427 }
2428
2429 static VALUE ruby_guestfs_umount_all (VALUE gv)
2430 {
2431   guestfs_h *g;
2432   Data_Get_Struct (gv, guestfs_h, g);
2433   if (!g)
2434     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
2435
2436
2437   int r;
2438
2439   r = guestfs_umount_all (g);
2440   if (r == -1)
2441     rb_raise (e_Error, "%s", guestfs_last_error (g));
2442
2443   return Qnil;
2444 }
2445
2446 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
2447 {
2448   guestfs_h *g;
2449   Data_Get_Struct (gv, guestfs_h, g);
2450   if (!g)
2451     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
2452
2453
2454   int r;
2455
2456   r = guestfs_lvm_remove_all (g);
2457   if (r == -1)
2458     rb_raise (e_Error, "%s", guestfs_last_error (g));
2459
2460   return Qnil;
2461 }
2462
2463 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
2464 {
2465   guestfs_h *g;
2466   Data_Get_Struct (gv, guestfs_h, g);
2467   if (!g)
2468     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
2469
2470   const char *path = StringValueCStr (pathv);
2471   if (!path)
2472     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2473               "path", "file");
2474
2475   char *r;
2476
2477   r = guestfs_file (g, path);
2478   if (r == NULL)
2479     rb_raise (e_Error, "%s", guestfs_last_error (g));
2480
2481   VALUE rv = rb_str_new2 (r);
2482   free (r);
2483   return rv;
2484 }
2485
2486 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
2487 {
2488   guestfs_h *g;
2489   Data_Get_Struct (gv, guestfs_h, g);
2490   if (!g)
2491     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
2492
2493   char **arguments;  {
2494     int i, len;
2495     len = RARRAY_LEN (argumentsv);
2496     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2497     for (i = 0; i < len; ++i) {
2498       VALUE v = rb_ary_entry (argumentsv, i);
2499       arguments[i] = StringValueCStr (v);
2500     }
2501     arguments[len] = NULL;
2502   }
2503
2504   char *r;
2505
2506   r = guestfs_command (g, arguments);
2507   free (arguments);
2508   if (r == NULL)
2509     rb_raise (e_Error, "%s", guestfs_last_error (g));
2510
2511   VALUE rv = rb_str_new2 (r);
2512   free (r);
2513   return rv;
2514 }
2515
2516 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
2517 {
2518   guestfs_h *g;
2519   Data_Get_Struct (gv, guestfs_h, g);
2520   if (!g)
2521     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
2522
2523   char **arguments;  {
2524     int i, len;
2525     len = RARRAY_LEN (argumentsv);
2526     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2527     for (i = 0; i < len; ++i) {
2528       VALUE v = rb_ary_entry (argumentsv, i);
2529       arguments[i] = StringValueCStr (v);
2530     }
2531     arguments[len] = NULL;
2532   }
2533
2534   char **r;
2535
2536   r = guestfs_command_lines (g, arguments);
2537   free (arguments);
2538   if (r == NULL)
2539     rb_raise (e_Error, "%s", guestfs_last_error (g));
2540
2541   int i, len = 0;
2542   for (i = 0; r[i] != NULL; ++i) len++;
2543   VALUE rv = rb_ary_new2 (len);
2544   for (i = 0; r[i] != NULL; ++i) {
2545     rb_ary_push (rv, rb_str_new2 (r[i]));
2546     free (r[i]);
2547   }
2548   free (r);
2549   return rv;
2550 }
2551
2552 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
2553 {
2554   guestfs_h *g;
2555   Data_Get_Struct (gv, guestfs_h, g);
2556   if (!g)
2557     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
2558
2559   const char *path = StringValueCStr (pathv);
2560   if (!path)
2561     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2562               "path", "stat");
2563
2564   struct guestfs_stat *r;
2565
2566   r = guestfs_stat (g, path);
2567   if (r == NULL)
2568     rb_raise (e_Error, "%s", guestfs_last_error (g));
2569
2570   VALUE rv = rb_hash_new ();
2571   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2572   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2573   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2574   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2575   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2576   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2577   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2578   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2579   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2580   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2581   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2582   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2583   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2584   free (r);
2585   return rv;
2586 }
2587
2588 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
2589 {
2590   guestfs_h *g;
2591   Data_Get_Struct (gv, guestfs_h, g);
2592   if (!g)
2593     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
2594
2595   const char *path = StringValueCStr (pathv);
2596   if (!path)
2597     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2598               "path", "lstat");
2599
2600   struct guestfs_stat *r;
2601
2602   r = guestfs_lstat (g, path);
2603   if (r == NULL)
2604     rb_raise (e_Error, "%s", guestfs_last_error (g));
2605
2606   VALUE rv = rb_hash_new ();
2607   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2608   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2609   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2610   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2611   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2612   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2613   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2614   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2615   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2616   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2617   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2618   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2619   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2620   free (r);
2621   return rv;
2622 }
2623
2624 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
2625 {
2626   guestfs_h *g;
2627   Data_Get_Struct (gv, guestfs_h, g);
2628   if (!g)
2629     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
2630
2631   const char *path = StringValueCStr (pathv);
2632   if (!path)
2633     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2634               "path", "statvfs");
2635
2636   struct guestfs_statvfs *r;
2637
2638   r = guestfs_statvfs (g, path);
2639   if (r == NULL)
2640     rb_raise (e_Error, "%s", guestfs_last_error (g));
2641
2642   VALUE rv = rb_hash_new ();
2643   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
2644   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
2645   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2646   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
2647   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
2648   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
2649   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
2650   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
2651   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
2652   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
2653   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
2654   free (r);
2655   return rv;
2656 }
2657
2658 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
2659 {
2660   guestfs_h *g;
2661   Data_Get_Struct (gv, guestfs_h, g);
2662   if (!g)
2663     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
2664
2665   const char *device = StringValueCStr (devicev);
2666   if (!device)
2667     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2668               "device", "tune2fs_l");
2669
2670   char **r;
2671
2672   r = guestfs_tune2fs_l (g, device);
2673   if (r == NULL)
2674     rb_raise (e_Error, "%s", guestfs_last_error (g));
2675
2676   VALUE rv = rb_hash_new ();
2677   int i;
2678   for (i = 0; r[i] != NULL; i+=2) {
2679     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
2680     free (r[i]);
2681     free (r[i+1]);
2682   }
2683   free (r);
2684   return rv;
2685 }
2686
2687 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
2688 {
2689   guestfs_h *g;
2690   Data_Get_Struct (gv, guestfs_h, g);
2691   if (!g)
2692     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
2693
2694   const char *device = StringValueCStr (devicev);
2695   if (!device)
2696     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2697               "device", "blockdev_setro");
2698
2699   int r;
2700
2701   r = guestfs_blockdev_setro (g, device);
2702   if (r == -1)
2703     rb_raise (e_Error, "%s", guestfs_last_error (g));
2704
2705   return Qnil;
2706 }
2707
2708 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
2709 {
2710   guestfs_h *g;
2711   Data_Get_Struct (gv, guestfs_h, g);
2712   if (!g)
2713     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
2714
2715   const char *device = StringValueCStr (devicev);
2716   if (!device)
2717     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2718               "device", "blockdev_setrw");
2719
2720   int r;
2721
2722   r = guestfs_blockdev_setrw (g, device);
2723   if (r == -1)
2724     rb_raise (e_Error, "%s", guestfs_last_error (g));
2725
2726   return Qnil;
2727 }
2728
2729 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
2730 {
2731   guestfs_h *g;
2732   Data_Get_Struct (gv, guestfs_h, g);
2733   if (!g)
2734     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
2735
2736   const char *device = StringValueCStr (devicev);
2737   if (!device)
2738     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2739               "device", "blockdev_getro");
2740
2741   int r;
2742
2743   r = guestfs_blockdev_getro (g, device);
2744   if (r == -1)
2745     rb_raise (e_Error, "%s", guestfs_last_error (g));
2746
2747   return INT2NUM (r);
2748 }
2749
2750 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
2751 {
2752   guestfs_h *g;
2753   Data_Get_Struct (gv, guestfs_h, g);
2754   if (!g)
2755     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
2756
2757   const char *device = StringValueCStr (devicev);
2758   if (!device)
2759     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2760               "device", "blockdev_getss");
2761
2762   int r;
2763
2764   r = guestfs_blockdev_getss (g, device);
2765   if (r == -1)
2766     rb_raise (e_Error, "%s", guestfs_last_error (g));
2767
2768   return INT2NUM (r);
2769 }
2770
2771 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
2772 {
2773   guestfs_h *g;
2774   Data_Get_Struct (gv, guestfs_h, g);
2775   if (!g)
2776     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
2777
2778   const char *device = StringValueCStr (devicev);
2779   if (!device)
2780     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2781               "device", "blockdev_getbsz");
2782
2783   int r;
2784
2785   r = guestfs_blockdev_getbsz (g, device);
2786   if (r == -1)
2787     rb_raise (e_Error, "%s", guestfs_last_error (g));
2788
2789   return INT2NUM (r);
2790 }
2791
2792 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2793 {
2794   guestfs_h *g;
2795   Data_Get_Struct (gv, guestfs_h, g);
2796   if (!g)
2797     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2798
2799   const char *device = StringValueCStr (devicev);
2800   if (!device)
2801     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2802               "device", "blockdev_setbsz");
2803   int blocksize = NUM2INT (blocksizev);
2804
2805   int r;
2806
2807   r = guestfs_blockdev_setbsz (g, device, blocksize);
2808   if (r == -1)
2809     rb_raise (e_Error, "%s", guestfs_last_error (g));
2810
2811   return Qnil;
2812 }
2813
2814 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2815 {
2816   guestfs_h *g;
2817   Data_Get_Struct (gv, guestfs_h, g);
2818   if (!g)
2819     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2820
2821   const char *device = StringValueCStr (devicev);
2822   if (!device)
2823     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2824               "device", "blockdev_getsz");
2825
2826   int64_t r;
2827
2828   r = guestfs_blockdev_getsz (g, device);
2829   if (r == -1)
2830     rb_raise (e_Error, "%s", guestfs_last_error (g));
2831
2832   return ULL2NUM (r);
2833 }
2834
2835 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2836 {
2837   guestfs_h *g;
2838   Data_Get_Struct (gv, guestfs_h, g);
2839   if (!g)
2840     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2841
2842   const char *device = StringValueCStr (devicev);
2843   if (!device)
2844     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2845               "device", "blockdev_getsize64");
2846
2847   int64_t r;
2848
2849   r = guestfs_blockdev_getsize64 (g, device);
2850   if (r == -1)
2851     rb_raise (e_Error, "%s", guestfs_last_error (g));
2852
2853   return ULL2NUM (r);
2854 }
2855
2856 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2857 {
2858   guestfs_h *g;
2859   Data_Get_Struct (gv, guestfs_h, g);
2860   if (!g)
2861     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2862
2863   const char *device = StringValueCStr (devicev);
2864   if (!device)
2865     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2866               "device", "blockdev_flushbufs");
2867
2868   int r;
2869
2870   r = guestfs_blockdev_flushbufs (g, device);
2871   if (r == -1)
2872     rb_raise (e_Error, "%s", guestfs_last_error (g));
2873
2874   return Qnil;
2875 }
2876
2877 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2878 {
2879   guestfs_h *g;
2880   Data_Get_Struct (gv, guestfs_h, g);
2881   if (!g)
2882     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2883
2884   const char *device = StringValueCStr (devicev);
2885   if (!device)
2886     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2887               "device", "blockdev_rereadpt");
2888
2889   int r;
2890
2891   r = guestfs_blockdev_rereadpt (g, device);
2892   if (r == -1)
2893     rb_raise (e_Error, "%s", guestfs_last_error (g));
2894
2895   return Qnil;
2896 }
2897
2898 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2899 {
2900   guestfs_h *g;
2901   Data_Get_Struct (gv, guestfs_h, g);
2902   if (!g)
2903     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2904
2905   const char *filename = StringValueCStr (filenamev);
2906   if (!filename)
2907     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2908               "filename", "upload");
2909   const char *remotefilename = StringValueCStr (remotefilenamev);
2910   if (!remotefilename)
2911     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2912               "remotefilename", "upload");
2913
2914   int r;
2915
2916   r = guestfs_upload (g, filename, remotefilename);
2917   if (r == -1)
2918     rb_raise (e_Error, "%s", guestfs_last_error (g));
2919
2920   return Qnil;
2921 }
2922
2923 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2924 {
2925   guestfs_h *g;
2926   Data_Get_Struct (gv, guestfs_h, g);
2927   if (!g)
2928     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2929
2930   const char *remotefilename = StringValueCStr (remotefilenamev);
2931   if (!remotefilename)
2932     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2933               "remotefilename", "download");
2934   const char *filename = StringValueCStr (filenamev);
2935   if (!filename)
2936     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2937               "filename", "download");
2938
2939   int r;
2940
2941   r = guestfs_download (g, remotefilename, filename);
2942   if (r == -1)
2943     rb_raise (e_Error, "%s", guestfs_last_error (g));
2944
2945   return Qnil;
2946 }
2947
2948 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2949 {
2950   guestfs_h *g;
2951   Data_Get_Struct (gv, guestfs_h, g);
2952   if (!g)
2953     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2954
2955   const char *csumtype = StringValueCStr (csumtypev);
2956   if (!csumtype)
2957     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2958               "csumtype", "checksum");
2959   const char *path = StringValueCStr (pathv);
2960   if (!path)
2961     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2962               "path", "checksum");
2963
2964   char *r;
2965
2966   r = guestfs_checksum (g, csumtype, path);
2967   if (r == NULL)
2968     rb_raise (e_Error, "%s", guestfs_last_error (g));
2969
2970   VALUE rv = rb_str_new2 (r);
2971   free (r);
2972   return rv;
2973 }
2974
2975 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2976 {
2977   guestfs_h *g;
2978   Data_Get_Struct (gv, guestfs_h, g);
2979   if (!g)
2980     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
2981
2982   const char *tarfile = StringValueCStr (tarfilev);
2983   if (!tarfile)
2984     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2985               "tarfile", "tar_in");
2986   const char *directory = StringValueCStr (directoryv);
2987   if (!directory)
2988     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2989               "directory", "tar_in");
2990
2991   int r;
2992
2993   r = guestfs_tar_in (g, tarfile, directory);
2994   if (r == -1)
2995     rb_raise (e_Error, "%s", guestfs_last_error (g));
2996
2997   return Qnil;
2998 }
2999
3000 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
3001 {
3002   guestfs_h *g;
3003   Data_Get_Struct (gv, guestfs_h, g);
3004   if (!g)
3005     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
3006
3007   const char *directory = StringValueCStr (directoryv);
3008   if (!directory)
3009     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3010               "directory", "tar_out");
3011   const char *tarfile = StringValueCStr (tarfilev);
3012   if (!tarfile)
3013     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3014               "tarfile", "tar_out");
3015
3016   int r;
3017
3018   r = guestfs_tar_out (g, directory, tarfile);
3019   if (r == -1)
3020     rb_raise (e_Error, "%s", guestfs_last_error (g));
3021
3022   return Qnil;
3023 }
3024
3025 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
3026 {
3027   guestfs_h *g;
3028   Data_Get_Struct (gv, guestfs_h, g);
3029   if (!g)
3030     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
3031
3032   const char *tarball = StringValueCStr (tarballv);
3033   if (!tarball)
3034     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3035               "tarball", "tgz_in");
3036   const char *directory = StringValueCStr (directoryv);
3037   if (!directory)
3038     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3039               "directory", "tgz_in");
3040
3041   int r;
3042
3043   r = guestfs_tgz_in (g, tarball, directory);
3044   if (r == -1)
3045     rb_raise (e_Error, "%s", guestfs_last_error (g));
3046
3047   return Qnil;
3048 }
3049
3050 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
3051 {
3052   guestfs_h *g;
3053   Data_Get_Struct (gv, guestfs_h, g);
3054   if (!g)
3055     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
3056
3057   const char *directory = StringValueCStr (directoryv);
3058   if (!directory)
3059     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3060               "directory", "tgz_out");
3061   const char *tarball = StringValueCStr (tarballv);
3062   if (!tarball)
3063     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3064               "tarball", "tgz_out");
3065
3066   int r;
3067
3068   r = guestfs_tgz_out (g, directory, tarball);
3069   if (r == -1)
3070     rb_raise (e_Error, "%s", guestfs_last_error (g));
3071
3072   return Qnil;
3073 }
3074
3075 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
3076 {
3077   guestfs_h *g;
3078   Data_Get_Struct (gv, guestfs_h, g);
3079   if (!g)
3080     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
3081
3082   const char *device = StringValueCStr (devicev);
3083   if (!device)
3084     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3085               "device", "mount_ro");
3086   const char *mountpoint = StringValueCStr (mountpointv);
3087   if (!mountpoint)
3088     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3089               "mountpoint", "mount_ro");
3090
3091   int r;
3092
3093   r = guestfs_mount_ro (g, device, mountpoint);
3094   if (r == -1)
3095     rb_raise (e_Error, "%s", guestfs_last_error (g));
3096
3097   return Qnil;
3098 }
3099
3100 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
3101 {
3102   guestfs_h *g;
3103   Data_Get_Struct (gv, guestfs_h, g);
3104   if (!g)
3105     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
3106
3107   const char *options = StringValueCStr (optionsv);
3108   if (!options)
3109     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3110               "options", "mount_options");
3111   const char *device = StringValueCStr (devicev);
3112   if (!device)
3113     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3114               "device", "mount_options");
3115   const char *mountpoint = StringValueCStr (mountpointv);
3116   if (!mountpoint)
3117     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3118               "mountpoint", "mount_options");
3119
3120   int r;
3121
3122   r = guestfs_mount_options (g, options, device, mountpoint);
3123   if (r == -1)
3124     rb_raise (e_Error, "%s", guestfs_last_error (g));
3125
3126   return Qnil;
3127 }
3128
3129 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
3130 {
3131   guestfs_h *g;
3132   Data_Get_Struct (gv, guestfs_h, g);
3133   if (!g)
3134     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
3135
3136   const char *options = StringValueCStr (optionsv);
3137   if (!options)
3138     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3139               "options", "mount_vfs");
3140   const char *vfstype = StringValueCStr (vfstypev);
3141   if (!vfstype)
3142     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3143               "vfstype", "mount_vfs");
3144   const char *device = StringValueCStr (devicev);
3145   if (!device)
3146     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3147               "device", "mount_vfs");
3148   const char *mountpoint = StringValueCStr (mountpointv);
3149   if (!mountpoint)
3150     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3151               "mountpoint", "mount_vfs");
3152
3153   int r;
3154
3155   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3156   if (r == -1)
3157     rb_raise (e_Error, "%s", guestfs_last_error (g));
3158
3159   return Qnil;
3160 }
3161
3162 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
3163 {
3164   guestfs_h *g;
3165   Data_Get_Struct (gv, guestfs_h, g);
3166   if (!g)
3167     rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
3168
3169   const char *subcmd = StringValueCStr (subcmdv);
3170   if (!subcmd)
3171     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3172               "subcmd", "debug");
3173   char **extraargs;  {
3174     int i, len;
3175     len = RARRAY_LEN (extraargsv);
3176     extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3177     for (i = 0; i < len; ++i) {
3178       VALUE v = rb_ary_entry (extraargsv, i);
3179       extraargs[i] = StringValueCStr (v);
3180     }
3181     extraargs[len] = NULL;
3182   }
3183
3184   char *r;
3185
3186   r = guestfs_debug (g, subcmd, extraargs);
3187   free (extraargs);
3188   if (r == NULL)
3189     rb_raise (e_Error, "%s", guestfs_last_error (g));
3190
3191   VALUE rv = rb_str_new2 (r);
3192   free (r);
3193   return rv;
3194 }
3195
3196 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
3197 {
3198   guestfs_h *g;
3199   Data_Get_Struct (gv, guestfs_h, g);
3200   if (!g)
3201     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
3202
3203   const char *device = StringValueCStr (devicev);
3204   if (!device)
3205     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3206               "device", "lvremove");
3207
3208   int r;
3209
3210   r = guestfs_lvremove (g, device);
3211   if (r == -1)
3212     rb_raise (e_Error, "%s", guestfs_last_error (g));
3213
3214   return Qnil;
3215 }
3216
3217 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
3218 {
3219   guestfs_h *g;
3220   Data_Get_Struct (gv, guestfs_h, g);
3221   if (!g)
3222     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
3223
3224   const char *vgname = StringValueCStr (vgnamev);
3225   if (!vgname)
3226     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3227               "vgname", "vgremove");
3228
3229   int r;
3230
3231   r = guestfs_vgremove (g, vgname);
3232   if (r == -1)
3233     rb_raise (e_Error, "%s", guestfs_last_error (g));
3234
3235   return Qnil;
3236 }
3237
3238 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
3239 {
3240   guestfs_h *g;
3241   Data_Get_Struct (gv, guestfs_h, g);
3242   if (!g)
3243     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
3244
3245   const char *device = StringValueCStr (devicev);
3246   if (!device)
3247     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3248               "device", "pvremove");
3249
3250   int r;
3251
3252   r = guestfs_pvremove (g, device);
3253   if (r == -1)
3254     rb_raise (e_Error, "%s", guestfs_last_error (g));
3255
3256   return Qnil;
3257 }
3258
3259 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
3260 {
3261   guestfs_h *g;
3262   Data_Get_Struct (gv, guestfs_h, g);
3263   if (!g)
3264     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
3265
3266   const char *device = StringValueCStr (devicev);
3267   if (!device)
3268     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3269               "device", "set_e2label");
3270   const char *label = StringValueCStr (labelv);
3271   if (!label)
3272     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3273               "label", "set_e2label");
3274
3275   int r;
3276
3277   r = guestfs_set_e2label (g, device, label);
3278   if (r == -1)
3279     rb_raise (e_Error, "%s", guestfs_last_error (g));
3280
3281   return Qnil;
3282 }
3283
3284 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
3285 {
3286   guestfs_h *g;
3287   Data_Get_Struct (gv, guestfs_h, g);
3288   if (!g)
3289     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
3290
3291   const char *device = StringValueCStr (devicev);
3292   if (!device)
3293     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3294               "device", "get_e2label");
3295
3296   char *r;
3297
3298   r = guestfs_get_e2label (g, device);
3299   if (r == NULL)
3300     rb_raise (e_Error, "%s", guestfs_last_error (g));
3301
3302   VALUE rv = rb_str_new2 (r);
3303   free (r);
3304   return rv;
3305 }
3306
3307 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
3308 {
3309   guestfs_h *g;
3310   Data_Get_Struct (gv, guestfs_h, g);
3311   if (!g)
3312     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
3313
3314   const char *device = StringValueCStr (devicev);
3315   if (!device)
3316     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3317               "device", "set_e2uuid");
3318   const char *uuid = StringValueCStr (uuidv);
3319   if (!uuid)
3320     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3321               "uuid", "set_e2uuid");
3322
3323   int r;
3324
3325   r = guestfs_set_e2uuid (g, device, uuid);
3326   if (r == -1)
3327     rb_raise (e_Error, "%s", guestfs_last_error (g));
3328
3329   return Qnil;
3330 }
3331
3332 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
3333 {
3334   guestfs_h *g;
3335   Data_Get_Struct (gv, guestfs_h, g);
3336   if (!g)
3337     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
3338
3339   const char *device = StringValueCStr (devicev);
3340   if (!device)
3341     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3342               "device", "get_e2uuid");
3343
3344   char *r;
3345
3346   r = guestfs_get_e2uuid (g, device);
3347   if (r == NULL)
3348     rb_raise (e_Error, "%s", guestfs_last_error (g));
3349
3350   VALUE rv = rb_str_new2 (r);
3351   free (r);
3352   return rv;
3353 }
3354
3355 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
3356 {
3357   guestfs_h *g;
3358   Data_Get_Struct (gv, guestfs_h, g);
3359   if (!g)
3360     rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
3361
3362   const char *fstype = StringValueCStr (fstypev);
3363   if (!fstype)
3364     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3365               "fstype", "fsck");
3366   const char *device = StringValueCStr (devicev);
3367   if (!device)
3368     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3369               "device", "fsck");
3370
3371   int r;
3372
3373   r = guestfs_fsck (g, fstype, device);
3374   if (r == -1)
3375     rb_raise (e_Error, "%s", guestfs_last_error (g));
3376
3377   return INT2NUM (r);
3378 }
3379
3380 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
3381 {
3382   guestfs_h *g;
3383   Data_Get_Struct (gv, guestfs_h, g);
3384   if (!g)
3385     rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
3386
3387   const char *device = StringValueCStr (devicev);
3388   if (!device)
3389     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3390               "device", "zero");
3391
3392   int r;
3393
3394   r = guestfs_zero (g, device);
3395   if (r == -1)
3396     rb_raise (e_Error, "%s", guestfs_last_error (g));
3397
3398   return Qnil;
3399 }
3400
3401 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
3402 {
3403   guestfs_h *g;
3404   Data_Get_Struct (gv, guestfs_h, g);
3405   if (!g)
3406     rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
3407
3408   const char *root = StringValueCStr (rootv);
3409   if (!root)
3410     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3411               "root", "grub_install");
3412   const char *device = StringValueCStr (devicev);
3413   if (!device)
3414     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3415               "device", "grub_install");
3416
3417   int r;
3418
3419   r = guestfs_grub_install (g, root, device);
3420   if (r == -1)
3421     rb_raise (e_Error, "%s", guestfs_last_error (g));
3422
3423   return Qnil;
3424 }
3425
3426 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
3427 {
3428   guestfs_h *g;
3429   Data_Get_Struct (gv, guestfs_h, g);
3430   if (!g)
3431     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
3432
3433   const char *src = StringValueCStr (srcv);
3434   if (!src)
3435     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3436               "src", "cp");
3437   const char *dest = StringValueCStr (destv);
3438   if (!dest)
3439     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3440               "dest", "cp");
3441
3442   int r;
3443
3444   r = guestfs_cp (g, src, dest);
3445   if (r == -1)
3446     rb_raise (e_Error, "%s", guestfs_last_error (g));
3447
3448   return Qnil;
3449 }
3450
3451 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
3452 {
3453   guestfs_h *g;
3454   Data_Get_Struct (gv, guestfs_h, g);
3455   if (!g)
3456     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
3457
3458   const char *src = StringValueCStr (srcv);
3459   if (!src)
3460     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3461               "src", "cp_a");
3462   const char *dest = StringValueCStr (destv);
3463   if (!dest)
3464     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3465               "dest", "cp_a");
3466
3467   int r;
3468
3469   r = guestfs_cp_a (g, src, dest);
3470   if (r == -1)
3471     rb_raise (e_Error, "%s", guestfs_last_error (g));
3472
3473   return Qnil;
3474 }
3475
3476 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
3477 {
3478   guestfs_h *g;
3479   Data_Get_Struct (gv, guestfs_h, g);
3480   if (!g)
3481     rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
3482
3483   const char *src = StringValueCStr (srcv);
3484   if (!src)
3485     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3486               "src", "mv");
3487   const char *dest = StringValueCStr (destv);
3488   if (!dest)
3489     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3490               "dest", "mv");
3491
3492   int r;
3493
3494   r = guestfs_mv (g, src, dest);
3495   if (r == -1)
3496     rb_raise (e_Error, "%s", guestfs_last_error (g));
3497
3498   return Qnil;
3499 }
3500
3501 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
3502 {
3503   guestfs_h *g;
3504   Data_Get_Struct (gv, guestfs_h, g);
3505   if (!g)
3506     rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
3507
3508   int whattodrop = NUM2INT (whattodropv);
3509
3510   int r;
3511
3512   r = guestfs_drop_caches (g, whattodrop);
3513   if (r == -1)
3514     rb_raise (e_Error, "%s", guestfs_last_error (g));
3515
3516   return Qnil;
3517 }
3518
3519 static VALUE ruby_guestfs_dmesg (VALUE gv)
3520 {
3521   guestfs_h *g;
3522   Data_Get_Struct (gv, guestfs_h, g);
3523   if (!g)
3524     rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
3525
3526
3527   char *r;
3528
3529   r = guestfs_dmesg (g);
3530   if (r == NULL)
3531     rb_raise (e_Error, "%s", guestfs_last_error (g));
3532
3533   VALUE rv = rb_str_new2 (r);
3534   free (r);
3535   return rv;
3536 }
3537
3538 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
3539 {
3540   guestfs_h *g;
3541   Data_Get_Struct (gv, guestfs_h, g);
3542   if (!g)
3543     rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
3544
3545
3546   int r;
3547
3548   r = guestfs_ping_daemon (g);
3549   if (r == -1)
3550     rb_raise (e_Error, "%s", guestfs_last_error (g));
3551
3552   return Qnil;
3553 }
3554
3555 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
3556 {
3557   guestfs_h *g;
3558   Data_Get_Struct (gv, guestfs_h, g);
3559   if (!g)
3560     rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
3561
3562   const char *file1 = StringValueCStr (file1v);
3563   if (!file1)
3564     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3565               "file1", "equal");
3566   const char *file2 = StringValueCStr (file2v);
3567   if (!file2)
3568     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3569               "file2", "equal");
3570
3571   int r;
3572
3573   r = guestfs_equal (g, file1, file2);
3574   if (r == -1)
3575     rb_raise (e_Error, "%s", guestfs_last_error (g));
3576
3577   return INT2NUM (r);
3578 }
3579
3580 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
3581 {
3582   guestfs_h *g;
3583   Data_Get_Struct (gv, guestfs_h, g);
3584   if (!g)
3585     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
3586
3587   const char *path = StringValueCStr (pathv);
3588   if (!path)
3589     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3590               "path", "strings");
3591
3592   char **r;
3593
3594   r = guestfs_strings (g, path);
3595   if (r == NULL)
3596     rb_raise (e_Error, "%s", guestfs_last_error (g));
3597
3598   int i, len = 0;
3599   for (i = 0; r[i] != NULL; ++i) len++;
3600   VALUE rv = rb_ary_new2 (len);
3601   for (i = 0; r[i] != NULL; ++i) {
3602     rb_ary_push (rv, rb_str_new2 (r[i]));
3603     free (r[i]);
3604   }
3605   free (r);
3606   return rv;
3607 }
3608
3609 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
3610 {
3611   guestfs_h *g;
3612   Data_Get_Struct (gv, guestfs_h, g);
3613   if (!g)
3614     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
3615
3616   const char *encoding = StringValueCStr (encodingv);
3617   if (!encoding)
3618     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3619               "encoding", "strings_e");
3620   const char *path = StringValueCStr (pathv);
3621   if (!path)
3622     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3623               "path", "strings_e");
3624
3625   char **r;
3626
3627   r = guestfs_strings_e (g, encoding, path);
3628   if (r == NULL)
3629     rb_raise (e_Error, "%s", guestfs_last_error (g));
3630
3631   int i, len = 0;
3632   for (i = 0; r[i] != NULL; ++i) len++;
3633   VALUE rv = rb_ary_new2 (len);
3634   for (i = 0; r[i] != NULL; ++i) {
3635     rb_ary_push (rv, rb_str_new2 (r[i]));
3636     free (r[i]);
3637   }
3638   free (r);
3639   return rv;
3640 }
3641
3642 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
3643 {
3644   guestfs_h *g;
3645   Data_Get_Struct (gv, guestfs_h, g);
3646   if (!g)
3647     rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
3648
3649   const char *path = StringValueCStr (pathv);
3650   if (!path)
3651     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3652               "path", "hexdump");
3653
3654   char *r;
3655
3656   r = guestfs_hexdump (g, path);
3657   if (r == NULL)
3658     rb_raise (e_Error, "%s", guestfs_last_error (g));
3659
3660   VALUE rv = rb_str_new2 (r);
3661   free (r);
3662   return rv;
3663 }
3664
3665 static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev)
3666 {
3667   guestfs_h *g;
3668   Data_Get_Struct (gv, guestfs_h, g);
3669   if (!g)
3670     rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
3671
3672   const char *device = StringValueCStr (devicev);
3673   if (!device)
3674     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3675               "device", "zerofree");
3676
3677   int r;
3678
3679   r = guestfs_zerofree (g, device);
3680   if (r == -1)
3681     rb_raise (e_Error, "%s", guestfs_last_error (g));
3682
3683   return Qnil;
3684 }
3685
3686 static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev)
3687 {
3688   guestfs_h *g;
3689   Data_Get_Struct (gv, guestfs_h, g);
3690   if (!g)
3691     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
3692
3693   const char *device = StringValueCStr (devicev);
3694   if (!device)
3695     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3696               "device", "pvresize");
3697
3698   int r;
3699
3700   r = guestfs_pvresize (g, device);
3701   if (r == -1)
3702     rb_raise (e_Error, "%s", guestfs_last_error (g));
3703
3704   return Qnil;
3705 }
3706
3707 static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE nv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev)
3708 {
3709   guestfs_h *g;
3710   Data_Get_Struct (gv, guestfs_h, g);
3711   if (!g)
3712     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
3713
3714   const char *device = StringValueCStr (devicev);
3715   if (!device)
3716     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3717               "device", "sfdisk_N");
3718   int n = NUM2INT (nv);
3719   int cyls = NUM2INT (cylsv);
3720   int heads = NUM2INT (headsv);
3721   int sectors = NUM2INT (sectorsv);
3722   const char *line = StringValueCStr (linev);
3723   if (!line)
3724     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3725               "line", "sfdisk_N");
3726
3727   int r;
3728
3729   r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
3730   if (r == -1)
3731     rb_raise (e_Error, "%s", guestfs_last_error (g));
3732
3733   return Qnil;
3734 }
3735
3736 static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
3737 {
3738   guestfs_h *g;
3739   Data_Get_Struct (gv, guestfs_h, g);
3740   if (!g)
3741     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
3742
3743   const char *device = StringValueCStr (devicev);
3744   if (!device)
3745     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3746               "device", "sfdisk_l");
3747
3748   char *r;
3749
3750   r = guestfs_sfdisk_l (g, device);
3751   if (r == NULL)
3752     rb_raise (e_Error, "%s", guestfs_last_error (g));
3753
3754   VALUE rv = rb_str_new2 (r);
3755   free (r);
3756   return rv;
3757 }
3758
3759 static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
3760 {
3761   guestfs_h *g;
3762   Data_Get_Struct (gv, guestfs_h, g);
3763   if (!g)
3764     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
3765
3766   const char *device = StringValueCStr (devicev);
3767   if (!device)
3768     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3769               "device", "sfdisk_kernel_geometry");
3770
3771   char *r;
3772
3773   r = guestfs_sfdisk_kernel_geometry (g, device);
3774   if (r == NULL)
3775     rb_raise (e_Error, "%s", guestfs_last_error (g));
3776
3777   VALUE rv = rb_str_new2 (r);
3778   free (r);
3779   return rv;
3780 }
3781
3782 static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
3783 {
3784   guestfs_h *g;
3785   Data_Get_Struct (gv, guestfs_h, g);
3786   if (!g)
3787     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
3788
3789   const char *device = StringValueCStr (devicev);
3790   if (!device)
3791     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3792               "device", "sfdisk_disk_geometry");
3793
3794   char *r;
3795
3796   r = guestfs_sfdisk_disk_geometry (g, device);
3797   if (r == NULL)
3798     rb_raise (e_Error, "%s", guestfs_last_error (g));
3799
3800   VALUE rv = rb_str_new2 (r);
3801   free (r);
3802   return rv;
3803 }
3804
3805 static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
3806 {
3807   guestfs_h *g;
3808   Data_Get_Struct (gv, guestfs_h, g);
3809   if (!g)
3810     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
3811
3812   int activate = NUM2INT (activatev);
3813
3814   int r;
3815
3816   r = guestfs_vg_activate_all (g, activate);
3817   if (r == -1)
3818     rb_raise (e_Error, "%s", guestfs_last_error (g));
3819
3820   return Qnil;
3821 }
3822
3823 static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv)
3824 {
3825   guestfs_h *g;
3826   Data_Get_Struct (gv, guestfs_h, g);
3827   if (!g)
3828     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
3829
3830   int activate = NUM2INT (activatev);
3831   char **volgroups;  {
3832     int i, len;
3833     len = RARRAY_LEN (volgroupsv);
3834     volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3835     for (i = 0; i < len; ++i) {
3836       VALUE v = rb_ary_entry (volgroupsv, i);
3837       volgroups[i] = StringValueCStr (v);
3838     }
3839     volgroups[len] = NULL;
3840   }
3841
3842   int r;
3843
3844   r = guestfs_vg_activate (g, activate, volgroups);
3845   free (volgroups);
3846   if (r == -1)
3847     rb_raise (e_Error, "%s", guestfs_last_error (g));
3848
3849   return Qnil;
3850 }
3851
3852 static VALUE ruby_guestfs_lvresize (VALUE gv, VALUE devicev, VALUE mbytesv)
3853 {
3854   guestfs_h *g;
3855   Data_Get_Struct (gv, guestfs_h, g);
3856   if (!g)
3857     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize");
3858
3859   const char *device = StringValueCStr (devicev);
3860   if (!device)
3861     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3862               "device", "lvresize");
3863   int mbytes = NUM2INT (mbytesv);
3864
3865   int r;
3866
3867   r = guestfs_lvresize (g, device, mbytes);
3868   if (r == -1)
3869     rb_raise (e_Error, "%s", guestfs_last_error (g));
3870
3871   return Qnil;
3872 }
3873
3874 static VALUE ruby_guestfs_resize2fs (VALUE gv, VALUE devicev)
3875 {
3876   guestfs_h *g;
3877   Data_Get_Struct (gv, guestfs_h, g);
3878   if (!g)
3879     rb_raise (rb_eArgError, "%s: used handle after closing it", "resize2fs");
3880
3881   const char *device = StringValueCStr (devicev);
3882   if (!device)
3883     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3884               "device", "resize2fs");
3885
3886   int r;
3887
3888   r = guestfs_resize2fs (g, device);
3889   if (r == -1)
3890     rb_raise (e_Error, "%s", guestfs_last_error (g));
3891
3892   return Qnil;
3893 }
3894
3895 static VALUE ruby_guestfs_find (VALUE gv, VALUE directoryv)
3896 {
3897   guestfs_h *g;
3898   Data_Get_Struct (gv, guestfs_h, g);
3899   if (!g)
3900     rb_raise (rb_eArgError, "%s: used handle after closing it", "find");
3901
3902   const char *directory = StringValueCStr (directoryv);
3903   if (!directory)
3904     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3905               "directory", "find");
3906
3907   char **r;
3908
3909   r = guestfs_find (g, directory);
3910   if (r == NULL)
3911     rb_raise (e_Error, "%s", guestfs_last_error (g));
3912
3913   int i, len = 0;
3914   for (i = 0; r[i] != NULL; ++i) len++;
3915   VALUE rv = rb_ary_new2 (len);
3916   for (i = 0; r[i] != NULL; ++i) {
3917     rb_ary_push (rv, rb_str_new2 (r[i]));
3918     free (r[i]);
3919   }
3920   free (r);
3921   return rv;
3922 }
3923
3924 static VALUE ruby_guestfs_e2fsck_f (VALUE gv, VALUE devicev)
3925 {
3926   guestfs_h *g;
3927   Data_Get_Struct (gv, guestfs_h, g);
3928   if (!g)
3929     rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f");
3930
3931   const char *device = StringValueCStr (devicev);
3932   if (!device)
3933     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3934               "device", "e2fsck_f");
3935
3936   int r;
3937
3938   r = guestfs_e2fsck_f (g, device);
3939   if (r == -1)
3940     rb_raise (e_Error, "%s", guestfs_last_error (g));
3941
3942   return Qnil;
3943 }
3944
3945 /* Initialize the module. */
3946 void Init__guestfs ()
3947 {
3948   m_guestfs = rb_define_module ("Guestfs");
3949   c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
3950   e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
3951
3952   rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
3953   rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
3954
3955   rb_define_method (c_guestfs, "test0",
3956         ruby_guestfs_test0, 7);
3957   rb_define_method (c_guestfs, "test0rint",
3958         ruby_guestfs_test0rint, 1);
3959   rb_define_method (c_guestfs, "test0rinterr",
3960         ruby_guestfs_test0rinterr, 0);
3961   rb_define_method (c_guestfs, "test0rint64",
3962         ruby_guestfs_test0rint64, 1);
3963   rb_define_method (c_guestfs, "test0rint64err",
3964         ruby_guestfs_test0rint64err, 0);
3965   rb_define_method (c_guestfs, "test0rbool",
3966         ruby_guestfs_test0rbool, 1);
3967   rb_define_method (c_guestfs, "test0rboolerr",
3968         ruby_guestfs_test0rboolerr, 0);
3969   rb_define_method (c_guestfs, "test0rconststring",
3970         ruby_guestfs_test0rconststring, 1);
3971   rb_define_method (c_guestfs, "test0rconststringerr",
3972         ruby_guestfs_test0rconststringerr, 0);
3973   rb_define_method (c_guestfs, "test0rstring",
3974         ruby_guestfs_test0rstring, 1);
3975   rb_define_method (c_guestfs, "test0rstringerr",
3976         ruby_guestfs_test0rstringerr, 0);
3977   rb_define_method (c_guestfs, "test0rstringlist",
3978         ruby_guestfs_test0rstringlist, 1);
3979   rb_define_method (c_guestfs, "test0rstringlisterr",
3980         ruby_guestfs_test0rstringlisterr, 0);
3981   rb_define_method (c_guestfs, "test0rintbool",
3982         ruby_guestfs_test0rintbool, 1);
3983   rb_define_method (c_guestfs, "test0rintboolerr",
3984         ruby_guestfs_test0rintboolerr, 0);
3985   rb_define_method (c_guestfs, "test0rpvlist",
3986         ruby_guestfs_test0rpvlist, 1);
3987   rb_define_method (c_guestfs, "test0rpvlisterr",
3988         ruby_guestfs_test0rpvlisterr, 0);
3989   rb_define_method (c_guestfs, "test0rvglist",
3990         ruby_guestfs_test0rvglist, 1);
3991   rb_define_method (c_guestfs, "test0rvglisterr",
3992         ruby_guestfs_test0rvglisterr, 0);
3993   rb_define_method (c_guestfs, "test0rlvlist",
3994         ruby_guestfs_test0rlvlist, 1);
3995   rb_define_method (c_guestfs, "test0rlvlisterr",
3996         ruby_guestfs_test0rlvlisterr, 0);
3997   rb_define_method (c_guestfs, "test0rstat",
3998         ruby_guestfs_test0rstat, 1);
3999   rb_define_method (c_guestfs, "test0rstaterr",
4000         ruby_guestfs_test0rstaterr, 0);
4001   rb_define_method (c_guestfs, "test0rstatvfs",
4002         ruby_guestfs_test0rstatvfs, 1);
4003   rb_define_method (c_guestfs, "test0rstatvfserr",
4004         ruby_guestfs_test0rstatvfserr, 0);
4005   rb_define_method (c_guestfs, "test0rhashtable",
4006         ruby_guestfs_test0rhashtable, 1);
4007   rb_define_method (c_guestfs, "test0rhashtableerr",
4008         ruby_guestfs_test0rhashtableerr, 0);
4009   rb_define_method (c_guestfs, "launch",
4010         ruby_guestfs_launch, 0);
4011   rb_define_method (c_guestfs, "wait_ready",
4012         ruby_guestfs_wait_ready, 0);
4013   rb_define_method (c_guestfs, "kill_subprocess",
4014         ruby_guestfs_kill_subprocess, 0);
4015   rb_define_method (c_guestfs, "add_drive",
4016         ruby_guestfs_add_drive, 1);
4017   rb_define_method (c_guestfs, "add_cdrom",
4018         ruby_guestfs_add_cdrom, 1);
4019   rb_define_method (c_guestfs, "config",
4020         ruby_guestfs_config, 2);
4021   rb_define_method (c_guestfs, "set_qemu",
4022         ruby_guestfs_set_qemu, 1);
4023   rb_define_method (c_guestfs, "get_qemu",
4024         ruby_guestfs_get_qemu, 0);
4025   rb_define_method (c_guestfs, "set_path",
4026         ruby_guestfs_set_path, 1);
4027   rb_define_method (c_guestfs, "get_path",
4028         ruby_guestfs_get_path, 0);
4029   rb_define_method (c_guestfs, "set_append",
4030         ruby_guestfs_set_append, 1);
4031   rb_define_method (c_guestfs, "get_append",
4032         ruby_guestfs_get_append, 0);
4033   rb_define_method (c_guestfs, "set_autosync",
4034         ruby_guestfs_set_autosync, 1);
4035   rb_define_method (c_guestfs, "get_autosync",
4036         ruby_guestfs_get_autosync, 0);
4037   rb_define_method (c_guestfs, "set_verbose",
4038         ruby_guestfs_set_verbose, 1);
4039   rb_define_method (c_guestfs, "get_verbose",
4040         ruby_guestfs_get_verbose, 0);
4041   rb_define_method (c_guestfs, "is_ready",
4042         ruby_guestfs_is_ready, 0);
4043   rb_define_method (c_guestfs, "is_config",
4044         ruby_guestfs_is_config, 0);
4045   rb_define_method (c_guestfs, "is_launching",
4046         ruby_guestfs_is_launching, 0);
4047   rb_define_method (c_guestfs, "is_busy",
4048         ruby_guestfs_is_busy, 0);
4049   rb_define_method (c_guestfs, "get_state",
4050         ruby_guestfs_get_state, 0);
4051   rb_define_method (c_guestfs, "set_busy",
4052         ruby_guestfs_set_busy, 0);
4053   rb_define_method (c_guestfs, "set_ready",
4054         ruby_guestfs_set_ready, 0);
4055   rb_define_method (c_guestfs, "end_busy",
4056         ruby_guestfs_end_busy, 0);
4057   rb_define_method (c_guestfs, "mount",
4058         ruby_guestfs_mount, 2);
4059   rb_define_method (c_guestfs, "sync",
4060         ruby_guestfs_sync, 0);
4061   rb_define_method (c_guestfs, "touch",
4062         ruby_guestfs_touch, 1);
4063   rb_define_method (c_guestfs, "cat",
4064         ruby_guestfs_cat, 1);
4065   rb_define_method (c_guestfs, "ll",
4066         ruby_guestfs_ll, 1);
4067   rb_define_method (c_guestfs, "ls",
4068         ruby_guestfs_ls, 1);
4069   rb_define_method (c_guestfs, "list_devices",
4070         ruby_guestfs_list_devices, 0);
4071   rb_define_method (c_guestfs, "list_partitions",
4072         ruby_guestfs_list_partitions, 0);
4073   rb_define_method (c_guestfs, "pvs",
4074         ruby_guestfs_pvs, 0);
4075   rb_define_method (c_guestfs, "vgs",
4076         ruby_guestfs_vgs, 0);
4077   rb_define_method (c_guestfs, "lvs",
4078         ruby_guestfs_lvs, 0);
4079   rb_define_method (c_guestfs, "pvs_full",
4080         ruby_guestfs_pvs_full, 0);
4081   rb_define_method (c_guestfs, "vgs_full",
4082         ruby_guestfs_vgs_full, 0);
4083   rb_define_method (c_guestfs, "lvs_full",
4084         ruby_guestfs_lvs_full, 0);
4085   rb_define_method (c_guestfs, "read_lines",
4086         ruby_guestfs_read_lines, 1);
4087   rb_define_method (c_guestfs, "aug_init",
4088         ruby_guestfs_aug_init, 2);
4089   rb_define_method (c_guestfs, "aug_close",
4090         ruby_guestfs_aug_close, 0);
4091   rb_define_method (c_guestfs, "aug_defvar",
4092         ruby_guestfs_aug_defvar, 2);
4093   rb_define_method (c_guestfs, "aug_defnode",
4094         ruby_guestfs_aug_defnode, 3);
4095   rb_define_method (c_guestfs, "aug_get",
4096         ruby_guestfs_aug_get, 1);
4097   rb_define_method (c_guestfs, "aug_set",
4098         ruby_guestfs_aug_set, 2);
4099   rb_define_method (c_guestfs, "aug_insert",
4100         ruby_guestfs_aug_insert, 3);
4101   rb_define_method (c_guestfs, "aug_rm",
4102         ruby_guestfs_aug_rm, 1);
4103   rb_define_method (c_guestfs, "aug_mv",
4104         ruby_guestfs_aug_mv, 2);
4105   rb_define_method (c_guestfs, "aug_match",
4106         ruby_guestfs_aug_match, 1);
4107   rb_define_method (c_guestfs, "aug_save",
4108         ruby_guestfs_aug_save, 0);
4109   rb_define_method (c_guestfs, "aug_load",
4110         ruby_guestfs_aug_load, 0);
4111   rb_define_method (c_guestfs, "aug_ls",
4112         ruby_guestfs_aug_ls, 1);
4113   rb_define_method (c_guestfs, "rm",
4114         ruby_guestfs_rm, 1);
4115   rb_define_method (c_guestfs, "rmdir",
4116         ruby_guestfs_rmdir, 1);
4117   rb_define_method (c_guestfs, "rm_rf",
4118         ruby_guestfs_rm_rf, 1);
4119   rb_define_method (c_guestfs, "mkdir",
4120         ruby_guestfs_mkdir, 1);
4121   rb_define_method (c_guestfs, "mkdir_p",
4122         ruby_guestfs_mkdir_p, 1);
4123   rb_define_method (c_guestfs, "chmod",
4124         ruby_guestfs_chmod, 2);
4125   rb_define_method (c_guestfs, "chown",
4126         ruby_guestfs_chown, 3);
4127   rb_define_method (c_guestfs, "exists",
4128         ruby_guestfs_exists, 1);
4129   rb_define_method (c_guestfs, "is_file",
4130         ruby_guestfs_is_file, 1);
4131   rb_define_method (c_guestfs, "is_dir",
4132         ruby_guestfs_is_dir, 1);
4133   rb_define_method (c_guestfs, "pvcreate",
4134         ruby_guestfs_pvcreate, 1);
4135   rb_define_method (c_guestfs, "vgcreate",
4136         ruby_guestfs_vgcreate, 2);
4137   rb_define_method (c_guestfs, "lvcreate",
4138         ruby_guestfs_lvcreate, 3);
4139   rb_define_method (c_guestfs, "mkfs",
4140         ruby_guestfs_mkfs, 2);
4141   rb_define_method (c_guestfs, "sfdisk",
4142         ruby_guestfs_sfdisk, 5);
4143   rb_define_method (c_guestfs, "write_file",
4144         ruby_guestfs_write_file, 3);
4145   rb_define_method (c_guestfs, "umount",
4146         ruby_guestfs_umount, 1);
4147   rb_define_method (c_guestfs, "mounts",
4148         ruby_guestfs_mounts, 0);
4149   rb_define_method (c_guestfs, "umount_all",
4150         ruby_guestfs_umount_all, 0);
4151   rb_define_method (c_guestfs, "lvm_remove_all",
4152         ruby_guestfs_lvm_remove_all, 0);
4153   rb_define_method (c_guestfs, "file",
4154         ruby_guestfs_file, 1);
4155   rb_define_method (c_guestfs, "command",
4156         ruby_guestfs_command, 1);
4157   rb_define_method (c_guestfs, "command_lines",
4158         ruby_guestfs_command_lines, 1);
4159   rb_define_method (c_guestfs, "stat",
4160         ruby_guestfs_stat, 1);
4161   rb_define_method (c_guestfs, "lstat",
4162         ruby_guestfs_lstat, 1);
4163   rb_define_method (c_guestfs, "statvfs",
4164         ruby_guestfs_statvfs, 1);
4165   rb_define_method (c_guestfs, "tune2fs_l",
4166         ruby_guestfs_tune2fs_l, 1);
4167   rb_define_method (c_guestfs, "blockdev_setro",
4168         ruby_guestfs_blockdev_setro, 1);
4169   rb_define_method (c_guestfs, "blockdev_setrw",
4170         ruby_guestfs_blockdev_setrw, 1);
4171   rb_define_method (c_guestfs, "blockdev_getro",
4172         ruby_guestfs_blockdev_getro, 1);
4173   rb_define_method (c_guestfs, "blockdev_getss",
4174         ruby_guestfs_blockdev_getss, 1);
4175   rb_define_method (c_guestfs, "blockdev_getbsz",
4176         ruby_guestfs_blockdev_getbsz, 1);
4177   rb_define_method (c_guestfs, "blockdev_setbsz",
4178         ruby_guestfs_blockdev_setbsz, 2);
4179   rb_define_method (c_guestfs, "blockdev_getsz",
4180         ruby_guestfs_blockdev_getsz, 1);
4181   rb_define_method (c_guestfs, "blockdev_getsize64",
4182         ruby_guestfs_blockdev_getsize64, 1);
4183   rb_define_method (c_guestfs, "blockdev_flushbufs",
4184         ruby_guestfs_blockdev_flushbufs, 1);
4185   rb_define_method (c_guestfs, "blockdev_rereadpt",
4186         ruby_guestfs_blockdev_rereadpt, 1);
4187   rb_define_method (c_guestfs, "upload",
4188         ruby_guestfs_upload, 2);
4189   rb_define_method (c_guestfs, "download",
4190         ruby_guestfs_download, 2);
4191   rb_define_method (c_guestfs, "checksum",
4192         ruby_guestfs_checksum, 2);
4193   rb_define_method (c_guestfs, "tar_in",
4194         ruby_guestfs_tar_in, 2);
4195   rb_define_method (c_guestfs, "tar_out",
4196         ruby_guestfs_tar_out, 2);
4197   rb_define_method (c_guestfs, "tgz_in",
4198         ruby_guestfs_tgz_in, 2);
4199   rb_define_method (c_guestfs, "tgz_out",
4200         ruby_guestfs_tgz_out, 2);
4201   rb_define_method (c_guestfs, "mount_ro",
4202         ruby_guestfs_mount_ro, 2);
4203   rb_define_method (c_guestfs, "mount_options",
4204         ruby_guestfs_mount_options, 3);
4205   rb_define_method (c_guestfs, "mount_vfs",
4206         ruby_guestfs_mount_vfs, 4);
4207   rb_define_method (c_guestfs, "debug",
4208         ruby_guestfs_debug, 2);
4209   rb_define_method (c_guestfs, "lvremove",
4210         ruby_guestfs_lvremove, 1);
4211   rb_define_method (c_guestfs, "vgremove",
4212         ruby_guestfs_vgremove, 1);
4213   rb_define_method (c_guestfs, "pvremove",
4214         ruby_guestfs_pvremove, 1);
4215   rb_define_method (c_guestfs, "set_e2label",
4216         ruby_guestfs_set_e2label, 2);
4217   rb_define_method (c_guestfs, "get_e2label",
4218         ruby_guestfs_get_e2label, 1);
4219   rb_define_method (c_guestfs, "set_e2uuid",
4220         ruby_guestfs_set_e2uuid, 2);
4221   rb_define_method (c_guestfs, "get_e2uuid",
4222         ruby_guestfs_get_e2uuid, 1);
4223   rb_define_method (c_guestfs, "fsck",
4224         ruby_guestfs_fsck, 2);
4225   rb_define_method (c_guestfs, "zero",
4226         ruby_guestfs_zero, 1);
4227   rb_define_method (c_guestfs, "grub_install",
4228         ruby_guestfs_grub_install, 2);
4229   rb_define_method (c_guestfs, "cp",
4230         ruby_guestfs_cp, 2);
4231   rb_define_method (c_guestfs, "cp_a",
4232         ruby_guestfs_cp_a, 2);
4233   rb_define_method (c_guestfs, "mv",
4234         ruby_guestfs_mv, 2);
4235   rb_define_method (c_guestfs, "drop_caches",
4236         ruby_guestfs_drop_caches, 1);
4237   rb_define_method (c_guestfs, "dmesg",
4238         ruby_guestfs_dmesg, 0);
4239   rb_define_method (c_guestfs, "ping_daemon",
4240         ruby_guestfs_ping_daemon, 0);
4241   rb_define_method (c_guestfs, "equal",
4242         ruby_guestfs_equal, 2);
4243   rb_define_method (c_guestfs, "strings",
4244         ruby_guestfs_strings, 1);
4245   rb_define_method (c_guestfs, "strings_e",
4246         ruby_guestfs_strings_e, 2);
4247   rb_define_method (c_guestfs, "hexdump",
4248         ruby_guestfs_hexdump, 1);
4249   rb_define_method (c_guestfs, "zerofree",
4250         ruby_guestfs_zerofree, 1);
4251   rb_define_method (c_guestfs, "pvresize",
4252         ruby_guestfs_pvresize, 1);
4253   rb_define_method (c_guestfs, "sfdisk_N",
4254         ruby_guestfs_sfdisk_N, 6);
4255   rb_define_method (c_guestfs, "sfdisk_l",
4256         ruby_guestfs_sfdisk_l, 1);
4257   rb_define_method (c_guestfs, "sfdisk_kernel_geometry",
4258         ruby_guestfs_sfdisk_kernel_geometry, 1);
4259   rb_define_method (c_guestfs, "sfdisk_disk_geometry",
4260         ruby_guestfs_sfdisk_disk_geometry, 1);
4261   rb_define_method (c_guestfs, "vg_activate_all",
4262         ruby_guestfs_vg_activate_all, 1);
4263   rb_define_method (c_guestfs, "vg_activate",
4264         ruby_guestfs_vg_activate, 2);
4265   rb_define_method (c_guestfs, "lvresize",
4266         ruby_guestfs_lvresize, 2);
4267   rb_define_method (c_guestfs, "resize2fs",
4268         ruby_guestfs_resize2fs, 1);
4269   rb_define_method (c_guestfs, "find",
4270         ruby_guestfs_find, 1);
4271   rb_define_method (c_guestfs, "e2fsck_f",
4272         ruby_guestfs_e2fsck_f, 1);
4273 }