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 = !NIL_P (optstrv) ? StringValueCStr (optstrv) : NULL;
  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 = RTEST (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_add_drive_ro (VALUE gv, VALUE filenamev)
 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", "add_drive_ro");
 950
 951   const char *filename = StringValueCStr (filenamev);
 952   if (!filename)
 953     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 954               "filename", "add_drive_ro");
 955
 956   int r;
 957
 958   r = guestfs_add_drive_ro (g, filename);
 959   if (r == -1)
 960     rb_raise (e_Error, "%s", guestfs_last_error (g));
 961
 962   return Qnil;
 963 }
 964
 965 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
 966 {
 967   guestfs_h *g;
 968   Data_Get_Struct (gv, guestfs_h, g);
 969   if (!g)
 970     rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
 971
 972   const char *qemuparam = StringValueCStr (qemuparamv);
 973   if (!qemuparam)
 974     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 975               "qemuparam", "config");
 976   const char *qemuvalue = !NIL_P (qemuvaluev) ? StringValueCStr (qemuvaluev) : NULL;
 977
 978   int r;
 979
 980   r = guestfs_config (g, qemuparam, qemuvalue);
 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_set_qemu (VALUE gv, VALUE qemuv)
 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", "set_qemu");
 993
 994   const char *qemu = StringValueCStr (qemuv);
 995   if (!qemu)
 996     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 997               "qemu", "set_qemu");
 998
 999   int r;
1000
1001   r = guestfs_set_qemu (g, qemu);
1002   if (r == -1)
1003     rb_raise (e_Error, "%s", guestfs_last_error (g));
1004
1005   return Qnil;
1006 }
1007
1008 static VALUE ruby_guestfs_get_qemu (VALUE gv)
1009 {
1010   guestfs_h *g;
1011   Data_Get_Struct (gv, guestfs_h, g);
1012   if (!g)
1013     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
1014
1015
1016   const char *r;
1017
1018   r = guestfs_get_qemu (g);
1019   if (r == NULL)
1020     rb_raise (e_Error, "%s", guestfs_last_error (g));
1021
1022   return rb_str_new2 (r);
1023 }
1024
1025 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
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", "set_path");
1031
1032   const char *path = StringValueCStr (pathv);
1033   if (!path)
1034     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1035               "path", "set_path");
1036
1037   int r;
1038
1039   r = guestfs_set_path (g, path);
1040   if (r == -1)
1041     rb_raise (e_Error, "%s", guestfs_last_error (g));
1042
1043   return Qnil;
1044 }
1045
1046 static VALUE ruby_guestfs_get_path (VALUE gv)
1047 {
1048   guestfs_h *g;
1049   Data_Get_Struct (gv, guestfs_h, g);
1050   if (!g)
1051     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
1052
1053
1054   const char *r;
1055
1056   r = guestfs_get_path (g);
1057   if (r == NULL)
1058     rb_raise (e_Error, "%s", guestfs_last_error (g));
1059
1060   return rb_str_new2 (r);
1061 }
1062
1063 static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
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", "set_append");
1069
1070   const char *append = StringValueCStr (appendv);
1071   if (!append)
1072     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1073               "append", "set_append");
1074
1075   int r;
1076
1077   r = guestfs_set_append (g, append);
1078   if (r == -1)
1079     rb_raise (e_Error, "%s", guestfs_last_error (g));
1080
1081   return Qnil;
1082 }
1083
1084 static VALUE ruby_guestfs_get_append (VALUE gv)
1085 {
1086   guestfs_h *g;
1087   Data_Get_Struct (gv, guestfs_h, g);
1088   if (!g)
1089     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append");
1090
1091
1092   const char *r;
1093
1094   r = guestfs_get_append (g);
1095   if (r == NULL)
1096     rb_raise (e_Error, "%s", guestfs_last_error (g));
1097
1098   return rb_str_new2 (r);
1099 }
1100
1101 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
1102 {
1103   guestfs_h *g;
1104   Data_Get_Struct (gv, guestfs_h, g);
1105   if (!g)
1106     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
1107
1108   int autosync = RTEST (autosyncv);
1109
1110   int r;
1111
1112   r = guestfs_set_autosync (g, autosync);
1113   if (r == -1)
1114     rb_raise (e_Error, "%s", guestfs_last_error (g));
1115
1116   return Qnil;
1117 }
1118
1119 static VALUE ruby_guestfs_get_autosync (VALUE gv)
1120 {
1121   guestfs_h *g;
1122   Data_Get_Struct (gv, guestfs_h, g);
1123   if (!g)
1124     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
1125
1126
1127   int r;
1128
1129   r = guestfs_get_autosync (g);
1130   if (r == -1)
1131     rb_raise (e_Error, "%s", guestfs_last_error (g));
1132
1133   return INT2NUM (r);
1134 }
1135
1136 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
1137 {
1138   guestfs_h *g;
1139   Data_Get_Struct (gv, guestfs_h, g);
1140   if (!g)
1141     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
1142
1143   int verbose = RTEST (verbosev);
1144
1145   int r;
1146
1147   r = guestfs_set_verbose (g, verbose);
1148   if (r == -1)
1149     rb_raise (e_Error, "%s", guestfs_last_error (g));
1150
1151   return Qnil;
1152 }
1153
1154 static VALUE ruby_guestfs_get_verbose (VALUE gv)
1155 {
1156   guestfs_h *g;
1157   Data_Get_Struct (gv, guestfs_h, g);
1158   if (!g)
1159     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
1160
1161
1162   int r;
1163
1164   r = guestfs_get_verbose (g);
1165   if (r == -1)
1166     rb_raise (e_Error, "%s", guestfs_last_error (g));
1167
1168   return INT2NUM (r);
1169 }
1170
1171 static VALUE ruby_guestfs_is_ready (VALUE gv)
1172 {
1173   guestfs_h *g;
1174   Data_Get_Struct (gv, guestfs_h, g);
1175   if (!g)
1176     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
1177
1178
1179   int r;
1180
1181   r = guestfs_is_ready (g);
1182   if (r == -1)
1183     rb_raise (e_Error, "%s", guestfs_last_error (g));
1184
1185   return INT2NUM (r);
1186 }
1187
1188 static VALUE ruby_guestfs_is_config (VALUE gv)
1189 {
1190   guestfs_h *g;
1191   Data_Get_Struct (gv, guestfs_h, g);
1192   if (!g)
1193     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
1194
1195
1196   int r;
1197
1198   r = guestfs_is_config (g);
1199   if (r == -1)
1200     rb_raise (e_Error, "%s", guestfs_last_error (g));
1201
1202   return INT2NUM (r);
1203 }
1204
1205 static VALUE ruby_guestfs_is_launching (VALUE gv)
1206 {
1207   guestfs_h *g;
1208   Data_Get_Struct (gv, guestfs_h, g);
1209   if (!g)
1210     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
1211
1212
1213   int r;
1214
1215   r = guestfs_is_launching (g);
1216   if (r == -1)
1217     rb_raise (e_Error, "%s", guestfs_last_error (g));
1218
1219   return INT2NUM (r);
1220 }
1221
1222 static VALUE ruby_guestfs_is_busy (VALUE gv)
1223 {
1224   guestfs_h *g;
1225   Data_Get_Struct (gv, guestfs_h, g);
1226   if (!g)
1227     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
1228
1229
1230   int r;
1231
1232   r = guestfs_is_busy (g);
1233   if (r == -1)
1234     rb_raise (e_Error, "%s", guestfs_last_error (g));
1235
1236   return INT2NUM (r);
1237 }
1238
1239 static VALUE ruby_guestfs_get_state (VALUE gv)
1240 {
1241   guestfs_h *g;
1242   Data_Get_Struct (gv, guestfs_h, g);
1243   if (!g)
1244     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
1245
1246
1247   int r;
1248
1249   r = guestfs_get_state (g);
1250   if (r == -1)
1251     rb_raise (e_Error, "%s", guestfs_last_error (g));
1252
1253   return INT2NUM (r);
1254 }
1255
1256 static VALUE ruby_guestfs_set_busy (VALUE gv)
1257 {
1258   guestfs_h *g;
1259   Data_Get_Struct (gv, guestfs_h, g);
1260   if (!g)
1261     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
1262
1263
1264   int r;
1265
1266   r = guestfs_set_busy (g);
1267   if (r == -1)
1268     rb_raise (e_Error, "%s", guestfs_last_error (g));
1269
1270   return Qnil;
1271 }
1272
1273 static VALUE ruby_guestfs_set_ready (VALUE gv)
1274 {
1275   guestfs_h *g;
1276   Data_Get_Struct (gv, guestfs_h, g);
1277   if (!g)
1278     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
1279
1280
1281   int r;
1282
1283   r = guestfs_set_ready (g);
1284   if (r == -1)
1285     rb_raise (e_Error, "%s", guestfs_last_error (g));
1286
1287   return Qnil;
1288 }
1289
1290 static VALUE ruby_guestfs_end_busy (VALUE gv)
1291 {
1292   guestfs_h *g;
1293   Data_Get_Struct (gv, guestfs_h, g);
1294   if (!g)
1295     rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
1296
1297
1298   int r;
1299
1300   r = guestfs_end_busy (g);
1301   if (r == -1)
1302     rb_raise (e_Error, "%s", guestfs_last_error (g));
1303
1304   return Qnil;
1305 }
1306
1307 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
1308 {
1309   guestfs_h *g;
1310   Data_Get_Struct (gv, guestfs_h, g);
1311   if (!g)
1312     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
1313
1314   const char *device = StringValueCStr (devicev);
1315   if (!device)
1316     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1317               "device", "mount");
1318   const char *mountpoint = StringValueCStr (mountpointv);
1319   if (!mountpoint)
1320     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1321               "mountpoint", "mount");
1322
1323   int r;
1324
1325   r = guestfs_mount (g, device, mountpoint);
1326   if (r == -1)
1327     rb_raise (e_Error, "%s", guestfs_last_error (g));
1328
1329   return Qnil;
1330 }
1331
1332 static VALUE ruby_guestfs_sync (VALUE gv)
1333 {
1334   guestfs_h *g;
1335   Data_Get_Struct (gv, guestfs_h, g);
1336   if (!g)
1337     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
1338
1339
1340   int r;
1341
1342   r = guestfs_sync (g);
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_touch (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", "touch");
1355
1356   const char *path = StringValueCStr (pathv);
1357   if (!path)
1358     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1359               "path", "touch");
1360
1361   int r;
1362
1363   r = guestfs_touch (g, path);
1364   if (r == -1)
1365     rb_raise (e_Error, "%s", guestfs_last_error (g));
1366
1367   return Qnil;
1368 }
1369
1370 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
1371 {
1372   guestfs_h *g;
1373   Data_Get_Struct (gv, guestfs_h, g);
1374   if (!g)
1375     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
1376
1377   const char *path = StringValueCStr (pathv);
1378   if (!path)
1379     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1380               "path", "cat");
1381
1382   char *r;
1383
1384   r = guestfs_cat (g, path);
1385   if (r == NULL)
1386     rb_raise (e_Error, "%s", guestfs_last_error (g));
1387
1388   VALUE rv = rb_str_new2 (r);
1389   free (r);
1390   return rv;
1391 }
1392
1393 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
1394 {
1395   guestfs_h *g;
1396   Data_Get_Struct (gv, guestfs_h, g);
1397   if (!g)
1398     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
1399
1400   const char *directory = StringValueCStr (directoryv);
1401   if (!directory)
1402     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1403               "directory", "ll");
1404
1405   char *r;
1406
1407   r = guestfs_ll (g, directory);
1408   if (r == NULL)
1409     rb_raise (e_Error, "%s", guestfs_last_error (g));
1410
1411   VALUE rv = rb_str_new2 (r);
1412   free (r);
1413   return rv;
1414 }
1415
1416 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
1417 {
1418   guestfs_h *g;
1419   Data_Get_Struct (gv, guestfs_h, g);
1420   if (!g)
1421     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
1422
1423   const char *directory = StringValueCStr (directoryv);
1424   if (!directory)
1425     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1426               "directory", "ls");
1427
1428   char **r;
1429
1430   r = guestfs_ls (g, directory);
1431   if (r == NULL)
1432     rb_raise (e_Error, "%s", guestfs_last_error (g));
1433
1434   int i, len = 0;
1435   for (i = 0; r[i] != NULL; ++i) len++;
1436   VALUE rv = rb_ary_new2 (len);
1437   for (i = 0; r[i] != NULL; ++i) {
1438     rb_ary_push (rv, rb_str_new2 (r[i]));
1439     free (r[i]);
1440   }
1441   free (r);
1442   return rv;
1443 }
1444
1445 static VALUE ruby_guestfs_list_devices (VALUE gv)
1446 {
1447   guestfs_h *g;
1448   Data_Get_Struct (gv, guestfs_h, g);
1449   if (!g)
1450     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
1451
1452
1453   char **r;
1454
1455   r = guestfs_list_devices (g);
1456   if (r == NULL)
1457     rb_raise (e_Error, "%s", guestfs_last_error (g));
1458
1459   int i, len = 0;
1460   for (i = 0; r[i] != NULL; ++i) len++;
1461   VALUE rv = rb_ary_new2 (len);
1462   for (i = 0; r[i] != NULL; ++i) {
1463     rb_ary_push (rv, rb_str_new2 (r[i]));
1464     free (r[i]);
1465   }
1466   free (r);
1467   return rv;
1468 }
1469
1470 static VALUE ruby_guestfs_list_partitions (VALUE gv)
1471 {
1472   guestfs_h *g;
1473   Data_Get_Struct (gv, guestfs_h, g);
1474   if (!g)
1475     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
1476
1477
1478   char **r;
1479
1480   r = guestfs_list_partitions (g);
1481   if (r == NULL)
1482     rb_raise (e_Error, "%s", guestfs_last_error (g));
1483
1484   int i, len = 0;
1485   for (i = 0; r[i] != NULL; ++i) len++;
1486   VALUE rv = rb_ary_new2 (len);
1487   for (i = 0; r[i] != NULL; ++i) {
1488     rb_ary_push (rv, rb_str_new2 (r[i]));
1489     free (r[i]);
1490   }
1491   free (r);
1492   return rv;
1493 }
1494
1495 static VALUE ruby_guestfs_pvs (VALUE gv)
1496 {
1497   guestfs_h *g;
1498   Data_Get_Struct (gv, guestfs_h, g);
1499   if (!g)
1500     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
1501
1502
1503   char **r;
1504
1505   r = guestfs_pvs (g);
1506   if (r == NULL)
1507     rb_raise (e_Error, "%s", guestfs_last_error (g));
1508
1509   int i, len = 0;
1510   for (i = 0; r[i] != NULL; ++i) len++;
1511   VALUE rv = rb_ary_new2 (len);
1512   for (i = 0; r[i] != NULL; ++i) {
1513     rb_ary_push (rv, rb_str_new2 (r[i]));
1514     free (r[i]);
1515   }
1516   free (r);
1517   return rv;
1518 }
1519
1520 static VALUE ruby_guestfs_vgs (VALUE gv)
1521 {
1522   guestfs_h *g;
1523   Data_Get_Struct (gv, guestfs_h, g);
1524   if (!g)
1525     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
1526
1527
1528   char **r;
1529
1530   r = guestfs_vgs (g);
1531   if (r == NULL)
1532     rb_raise (e_Error, "%s", guestfs_last_error (g));
1533
1534   int i, len = 0;
1535   for (i = 0; r[i] != NULL; ++i) len++;
1536   VALUE rv = rb_ary_new2 (len);
1537   for (i = 0; r[i] != NULL; ++i) {
1538     rb_ary_push (rv, rb_str_new2 (r[i]));
1539     free (r[i]);
1540   }
1541   free (r);
1542   return rv;
1543 }
1544
1545 static VALUE ruby_guestfs_lvs (VALUE gv)
1546 {
1547   guestfs_h *g;
1548   Data_Get_Struct (gv, guestfs_h, g);
1549   if (!g)
1550     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
1551
1552
1553   char **r;
1554
1555   r = guestfs_lvs (g);
1556   if (r == NULL)
1557     rb_raise (e_Error, "%s", guestfs_last_error (g));
1558
1559   int i, len = 0;
1560   for (i = 0; r[i] != NULL; ++i) len++;
1561   VALUE rv = rb_ary_new2 (len);
1562   for (i = 0; r[i] != NULL; ++i) {
1563     rb_ary_push (rv, rb_str_new2 (r[i]));
1564     free (r[i]);
1565   }
1566   free (r);
1567   return rv;
1568 }
1569
1570 static VALUE ruby_guestfs_pvs_full (VALUE gv)
1571 {
1572   guestfs_h *g;
1573   Data_Get_Struct (gv, guestfs_h, g);
1574   if (!g)
1575     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
1576
1577
1578   struct guestfs_lvm_pv_list *r;
1579
1580   r = guestfs_pvs_full (g);
1581   if (r == NULL)
1582     rb_raise (e_Error, "%s", guestfs_last_error (g));
1583
1584   VALUE rv = rb_ary_new2 (r->len);
1585   int i;
1586   for (i = 0; i < r->len; ++i) {
1587     VALUE hv = rb_hash_new ();
1588     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
1589     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
1590     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
1591     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
1592     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
1593     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
1594     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
1595     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
1596     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
1597     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
1598     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
1599     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
1600     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
1601     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
1602     rb_ary_push (rv, hv);
1603   }
1604   guestfs_free_lvm_pv_list (r);
1605   return rv;
1606 }
1607
1608 static VALUE ruby_guestfs_vgs_full (VALUE gv)
1609 {
1610   guestfs_h *g;
1611   Data_Get_Struct (gv, guestfs_h, g);
1612   if (!g)
1613     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
1614
1615
1616   struct guestfs_lvm_vg_list *r;
1617
1618   r = guestfs_vgs_full (g);
1619   if (r == NULL)
1620     rb_raise (e_Error, "%s", guestfs_last_error (g));
1621
1622   VALUE rv = rb_ary_new2 (r->len);
1623   int i;
1624   for (i = 0; i < r->len; ++i) {
1625     VALUE hv = rb_hash_new ();
1626     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
1627     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
1628     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
1629     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
1630     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
1631     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
1632     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
1633     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
1634     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
1635     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
1636     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
1637     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
1638     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
1639     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
1640     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
1641     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
1642     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
1643     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
1644     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
1645     rb_ary_push (rv, hv);
1646   }
1647   guestfs_free_lvm_vg_list (r);
1648   return rv;
1649 }
1650
1651 static VALUE ruby_guestfs_lvs_full (VALUE gv)
1652 {
1653   guestfs_h *g;
1654   Data_Get_Struct (gv, guestfs_h, g);
1655   if (!g)
1656     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
1657
1658
1659   struct guestfs_lvm_lv_list *r;
1660
1661   r = guestfs_lvs_full (g);
1662   if (r == NULL)
1663     rb_raise (e_Error, "%s", guestfs_last_error (g));
1664
1665   VALUE rv = rb_ary_new2 (r->len);
1666   int i;
1667   for (i = 0; i < r->len; ++i) {
1668     VALUE hv = rb_hash_new ();
1669     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
1670     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
1671     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
1672     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
1673     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
1674     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
1675     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
1676     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
1677     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
1678     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
1679     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
1680     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
1681     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
1682     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
1683     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
1684     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
1685     rb_ary_push (rv, hv);
1686   }
1687   guestfs_free_lvm_lv_list (r);
1688   return rv;
1689 }
1690
1691 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
1692 {
1693   guestfs_h *g;
1694   Data_Get_Struct (gv, guestfs_h, g);
1695   if (!g)
1696     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
1697
1698   const char *path = StringValueCStr (pathv);
1699   if (!path)
1700     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1701               "path", "read_lines");
1702
1703   char **r;
1704
1705   r = guestfs_read_lines (g, path);
1706   if (r == NULL)
1707     rb_raise (e_Error, "%s", guestfs_last_error (g));
1708
1709   int i, len = 0;
1710   for (i = 0; r[i] != NULL; ++i) len++;
1711   VALUE rv = rb_ary_new2 (len);
1712   for (i = 0; r[i] != NULL; ++i) {
1713     rb_ary_push (rv, rb_str_new2 (r[i]));
1714     free (r[i]);
1715   }
1716   free (r);
1717   return rv;
1718 }
1719
1720 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
1721 {
1722   guestfs_h *g;
1723   Data_Get_Struct (gv, guestfs_h, g);
1724   if (!g)
1725     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
1726
1727   const char *root = StringValueCStr (rootv);
1728   if (!root)
1729     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1730               "root", "aug_init");
1731   int flags = NUM2INT (flagsv);
1732
1733   int r;
1734
1735   r = guestfs_aug_init (g, root, flags);
1736   if (r == -1)
1737     rb_raise (e_Error, "%s", guestfs_last_error (g));
1738
1739   return Qnil;
1740 }
1741
1742 static VALUE ruby_guestfs_aug_close (VALUE gv)
1743 {
1744   guestfs_h *g;
1745   Data_Get_Struct (gv, guestfs_h, g);
1746   if (!g)
1747     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
1748
1749
1750   int r;
1751
1752   r = guestfs_aug_close (g);
1753   if (r == -1)
1754     rb_raise (e_Error, "%s", guestfs_last_error (g));
1755
1756   return Qnil;
1757 }
1758
1759 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
1760 {
1761   guestfs_h *g;
1762   Data_Get_Struct (gv, guestfs_h, g);
1763   if (!g)
1764     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
1765
1766   const char *name = StringValueCStr (namev);
1767   if (!name)
1768     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1769               "name", "aug_defvar");
1770   const char *expr = !NIL_P (exprv) ? StringValueCStr (exprv) : NULL;
1771
1772   int r;
1773
1774   r = guestfs_aug_defvar (g, name, expr);
1775   if (r == -1)
1776     rb_raise (e_Error, "%s", guestfs_last_error (g));
1777
1778   return INT2NUM (r);
1779 }
1780
1781 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
1782 {
1783   guestfs_h *g;
1784   Data_Get_Struct (gv, guestfs_h, g);
1785   if (!g)
1786     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
1787
1788   const char *name = StringValueCStr (namev);
1789   if (!name)
1790     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1791               "name", "aug_defnode");
1792   const char *expr = StringValueCStr (exprv);
1793   if (!expr)
1794     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1795               "expr", "aug_defnode");
1796   const char *val = StringValueCStr (valv);
1797   if (!val)
1798     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1799               "val", "aug_defnode");
1800
1801   struct guestfs_int_bool *r;
1802
1803   r = guestfs_aug_defnode (g, name, expr, val);
1804   if (r == NULL)
1805     rb_raise (e_Error, "%s", guestfs_last_error (g));
1806
1807   VALUE rv = rb_ary_new2 (2);
1808   rb_ary_push (rv, INT2NUM (r->i));
1809   rb_ary_push (rv, INT2NUM (r->b));
1810   guestfs_free_int_bool (r);
1811   return rv;
1812 }
1813
1814 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1815 {
1816   guestfs_h *g;
1817   Data_Get_Struct (gv, guestfs_h, g);
1818   if (!g)
1819     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1820
1821   const char *path = StringValueCStr (pathv);
1822   if (!path)
1823     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1824               "path", "aug_get");
1825
1826   char *r;
1827
1828   r = guestfs_aug_get (g, path);
1829   if (r == NULL)
1830     rb_raise (e_Error, "%s", guestfs_last_error (g));
1831
1832   VALUE rv = rb_str_new2 (r);
1833   free (r);
1834   return rv;
1835 }
1836
1837 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1838 {
1839   guestfs_h *g;
1840   Data_Get_Struct (gv, guestfs_h, g);
1841   if (!g)
1842     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1843
1844   const char *path = StringValueCStr (pathv);
1845   if (!path)
1846     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1847               "path", "aug_set");
1848   const char *val = StringValueCStr (valv);
1849   if (!val)
1850     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1851               "val", "aug_set");
1852
1853   int r;
1854
1855   r = guestfs_aug_set (g, path, val);
1856   if (r == -1)
1857     rb_raise (e_Error, "%s", guestfs_last_error (g));
1858
1859   return Qnil;
1860 }
1861
1862 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1863 {
1864   guestfs_h *g;
1865   Data_Get_Struct (gv, guestfs_h, g);
1866   if (!g)
1867     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1868
1869   const char *path = StringValueCStr (pathv);
1870   if (!path)
1871     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1872               "path", "aug_insert");
1873   const char *label = StringValueCStr (labelv);
1874   if (!label)
1875     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1876               "label", "aug_insert");
1877   int before = RTEST (beforev);
1878
1879   int r;
1880
1881   r = guestfs_aug_insert (g, path, label, before);
1882   if (r == -1)
1883     rb_raise (e_Error, "%s", guestfs_last_error (g));
1884
1885   return Qnil;
1886 }
1887
1888 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
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_rm");
1894
1895   const char *path = StringValueCStr (pathv);
1896   if (!path)
1897     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1898               "path", "aug_rm");
1899
1900   int r;
1901
1902   r = guestfs_aug_rm (g, path);
1903   if (r == -1)
1904     rb_raise (e_Error, "%s", guestfs_last_error (g));
1905
1906   return INT2NUM (r);
1907 }
1908
1909 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1910 {
1911   guestfs_h *g;
1912   Data_Get_Struct (gv, guestfs_h, g);
1913   if (!g)
1914     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1915
1916   const char *src = StringValueCStr (srcv);
1917   if (!src)
1918     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1919               "src", "aug_mv");
1920   const char *dest = StringValueCStr (destv);
1921   if (!dest)
1922     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1923               "dest", "aug_mv");
1924
1925   int r;
1926
1927   r = guestfs_aug_mv (g, src, dest);
1928   if (r == -1)
1929     rb_raise (e_Error, "%s", guestfs_last_error (g));
1930
1931   return Qnil;
1932 }
1933
1934 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1935 {
1936   guestfs_h *g;
1937   Data_Get_Struct (gv, guestfs_h, g);
1938   if (!g)
1939     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1940
1941   const char *path = StringValueCStr (pathv);
1942   if (!path)
1943     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1944               "path", "aug_match");
1945
1946   char **r;
1947
1948   r = guestfs_aug_match (g, path);
1949   if (r == NULL)
1950     rb_raise (e_Error, "%s", guestfs_last_error (g));
1951
1952   int i, len = 0;
1953   for (i = 0; r[i] != NULL; ++i) len++;
1954   VALUE rv = rb_ary_new2 (len);
1955   for (i = 0; r[i] != NULL; ++i) {
1956     rb_ary_push (rv, rb_str_new2 (r[i]));
1957     free (r[i]);
1958   }
1959   free (r);
1960   return rv;
1961 }
1962
1963 static VALUE ruby_guestfs_aug_save (VALUE gv)
1964 {
1965   guestfs_h *g;
1966   Data_Get_Struct (gv, guestfs_h, g);
1967   if (!g)
1968     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1969
1970
1971   int r;
1972
1973   r = guestfs_aug_save (g);
1974   if (r == -1)
1975     rb_raise (e_Error, "%s", guestfs_last_error (g));
1976
1977   return Qnil;
1978 }
1979
1980 static VALUE ruby_guestfs_aug_load (VALUE gv)
1981 {
1982   guestfs_h *g;
1983   Data_Get_Struct (gv, guestfs_h, g);
1984   if (!g)
1985     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1986
1987
1988   int r;
1989
1990   r = guestfs_aug_load (g);
1991   if (r == -1)
1992     rb_raise (e_Error, "%s", guestfs_last_error (g));
1993
1994   return Qnil;
1995 }
1996
1997 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1998 {
1999   guestfs_h *g;
2000   Data_Get_Struct (gv, guestfs_h, g);
2001   if (!g)
2002     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
2003
2004   const char *path = StringValueCStr (pathv);
2005   if (!path)
2006     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2007               "path", "aug_ls");
2008
2009   char **r;
2010
2011   r = guestfs_aug_ls (g, path);
2012   if (r == NULL)
2013     rb_raise (e_Error, "%s", guestfs_last_error (g));
2014
2015   int i, len = 0;
2016   for (i = 0; r[i] != NULL; ++i) len++;
2017   VALUE rv = rb_ary_new2 (len);
2018   for (i = 0; r[i] != NULL; ++i) {
2019     rb_ary_push (rv, rb_str_new2 (r[i]));
2020     free (r[i]);
2021   }
2022   free (r);
2023   return rv;
2024 }
2025
2026 static VALUE ruby_guestfs_rm (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", "rm");
2032
2033   const char *path = StringValueCStr (pathv);
2034   if (!path)
2035     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2036               "path", "rm");
2037
2038   int r;
2039
2040   r = guestfs_rm (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_rmdir (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", "rmdir");
2053
2054   const char *path = StringValueCStr (pathv);
2055   if (!path)
2056     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2057               "path", "rmdir");
2058
2059   int r;
2060
2061   r = guestfs_rmdir (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_rm_rf (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", "rm_rf");
2074
2075   const char *path = StringValueCStr (pathv);
2076   if (!path)
2077     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2078               "path", "rm_rf");
2079
2080   int r;
2081
2082   r = guestfs_rm_rf (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 (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");
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");
2100
2101   int r;
2102
2103   r = guestfs_mkdir (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_mkdir_p (VALUE gv, 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", "mkdir_p");
2116
2117   const char *path = StringValueCStr (pathv);
2118   if (!path)
2119     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2120               "path", "mkdir_p");
2121
2122   int r;
2123
2124   r = guestfs_mkdir_p (g, path);
2125   if (r == -1)
2126     rb_raise (e_Error, "%s", guestfs_last_error (g));
2127
2128   return Qnil;
2129 }
2130
2131 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
2132 {
2133   guestfs_h *g;
2134   Data_Get_Struct (gv, guestfs_h, g);
2135   if (!g)
2136     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
2137
2138   int mode = NUM2INT (modev);
2139   const char *path = StringValueCStr (pathv);
2140   if (!path)
2141     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2142               "path", "chmod");
2143
2144   int r;
2145
2146   r = guestfs_chmod (g, mode, path);
2147   if (r == -1)
2148     rb_raise (e_Error, "%s", guestfs_last_error (g));
2149
2150   return Qnil;
2151 }
2152
2153 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
2154 {
2155   guestfs_h *g;
2156   Data_Get_Struct (gv, guestfs_h, g);
2157   if (!g)
2158     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
2159
2160   int owner = NUM2INT (ownerv);
2161   int group = NUM2INT (groupv);
2162   const char *path = StringValueCStr (pathv);
2163   if (!path)
2164     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2165               "path", "chown");
2166
2167   int r;
2168
2169   r = guestfs_chown (g, owner, group, path);
2170   if (r == -1)
2171     rb_raise (e_Error, "%s", guestfs_last_error (g));
2172
2173   return Qnil;
2174 }
2175
2176 static VALUE ruby_guestfs_exists (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", "exists");
2182
2183   const char *path = StringValueCStr (pathv);
2184   if (!path)
2185     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2186               "path", "exists");
2187
2188   int r;
2189
2190   r = guestfs_exists (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_file (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_file");
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_file");
2208
2209   int r;
2210
2211   r = guestfs_is_file (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_is_dir (VALUE gv, VALUE pathv)
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", "is_dir");
2224
2225   const char *path = StringValueCStr (pathv);
2226   if (!path)
2227     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2228               "path", "is_dir");
2229
2230   int r;
2231
2232   r = guestfs_is_dir (g, path);
2233   if (r == -1)
2234     rb_raise (e_Error, "%s", guestfs_last_error (g));
2235
2236   return INT2NUM (r);
2237 }
2238
2239 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
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", "pvcreate");
2245
2246   const char *device = StringValueCStr (devicev);
2247   if (!device)
2248     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2249               "device", "pvcreate");
2250
2251   int r;
2252
2253   r = guestfs_pvcreate (g, device);
2254   if (r == -1)
2255     rb_raise (e_Error, "%s", guestfs_last_error (g));
2256
2257   return Qnil;
2258 }
2259
2260 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
2261 {
2262   guestfs_h *g;
2263   Data_Get_Struct (gv, guestfs_h, g);
2264   if (!g)
2265     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
2266
2267   const char *volgroup = StringValueCStr (volgroupv);
2268   if (!volgroup)
2269     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2270               "volgroup", "vgcreate");
2271   char **physvols;  {
2272     int i, len;
2273     len = RARRAY_LEN (physvolsv);
2274     physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2275     for (i = 0; i < len; ++i) {
2276       VALUE v = rb_ary_entry (physvolsv, i);
2277       physvols[i] = StringValueCStr (v);
2278     }
2279     physvols[len] = NULL;
2280   }
2281
2282   int r;
2283
2284   r = guestfs_vgcreate (g, volgroup, physvols);
2285   free (physvols);
2286   if (r == -1)
2287     rb_raise (e_Error, "%s", guestfs_last_error (g));
2288
2289   return Qnil;
2290 }
2291
2292 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
2293 {
2294   guestfs_h *g;
2295   Data_Get_Struct (gv, guestfs_h, g);
2296   if (!g)
2297     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
2298
2299   const char *logvol = StringValueCStr (logvolv);
2300   if (!logvol)
2301     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2302               "logvol", "lvcreate");
2303   const char *volgroup = StringValueCStr (volgroupv);
2304   if (!volgroup)
2305     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2306               "volgroup", "lvcreate");
2307   int mbytes = NUM2INT (mbytesv);
2308
2309   int r;
2310
2311   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2312   if (r == -1)
2313     rb_raise (e_Error, "%s", guestfs_last_error (g));
2314
2315   return Qnil;
2316 }
2317
2318 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
2319 {
2320   guestfs_h *g;
2321   Data_Get_Struct (gv, guestfs_h, g);
2322   if (!g)
2323     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
2324
2325   const char *fstype = StringValueCStr (fstypev);
2326   if (!fstype)
2327     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2328               "fstype", "mkfs");
2329   const char *device = StringValueCStr (devicev);
2330   if (!device)
2331     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2332               "device", "mkfs");
2333
2334   int r;
2335
2336   r = guestfs_mkfs (g, fstype, device);
2337   if (r == -1)
2338     rb_raise (e_Error, "%s", guestfs_last_error (g));
2339
2340   return Qnil;
2341 }
2342
2343 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
2344 {
2345   guestfs_h *g;
2346   Data_Get_Struct (gv, guestfs_h, g);
2347   if (!g)
2348     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
2349
2350   const char *device = StringValueCStr (devicev);
2351   if (!device)
2352     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2353               "device", "sfdisk");
2354   int cyls = NUM2INT (cylsv);
2355   int heads = NUM2INT (headsv);
2356   int sectors = NUM2INT (sectorsv);
2357   char **lines;  {
2358     int i, len;
2359     len = RARRAY_LEN (linesv);
2360     lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2361     for (i = 0; i < len; ++i) {
2362       VALUE v = rb_ary_entry (linesv, i);
2363       lines[i] = StringValueCStr (v);
2364     }
2365     lines[len] = NULL;
2366   }
2367
2368   int r;
2369
2370   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2371   free (lines);
2372   if (r == -1)
2373     rb_raise (e_Error, "%s", guestfs_last_error (g));
2374
2375   return Qnil;
2376 }
2377
2378 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
2379 {
2380   guestfs_h *g;
2381   Data_Get_Struct (gv, guestfs_h, g);
2382   if (!g)
2383     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
2384
2385   const char *path = StringValueCStr (pathv);
2386   if (!path)
2387     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2388               "path", "write_file");
2389   const char *content = StringValueCStr (contentv);
2390   if (!content)
2391     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2392               "content", "write_file");
2393   int size = NUM2INT (sizev);
2394
2395   int r;
2396
2397   r = guestfs_write_file (g, path, content, size);
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_umount (VALUE gv, VALUE pathordevicev)
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", "umount");
2410
2411   const char *pathordevice = StringValueCStr (pathordevicev);
2412   if (!pathordevice)
2413     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2414               "pathordevice", "umount");
2415
2416   int r;
2417
2418   r = guestfs_umount (g, pathordevice);
2419   if (r == -1)
2420     rb_raise (e_Error, "%s", guestfs_last_error (g));
2421
2422   return Qnil;
2423 }
2424
2425 static VALUE ruby_guestfs_mounts (VALUE gv)
2426 {
2427   guestfs_h *g;
2428   Data_Get_Struct (gv, guestfs_h, g);
2429   if (!g)
2430     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
2431
2432
2433   char **r;
2434
2435   r = guestfs_mounts (g);
2436   if (r == NULL)
2437     rb_raise (e_Error, "%s", guestfs_last_error (g));
2438
2439   int i, len = 0;
2440   for (i = 0; r[i] != NULL; ++i) len++;
2441   VALUE rv = rb_ary_new2 (len);
2442   for (i = 0; r[i] != NULL; ++i) {
2443     rb_ary_push (rv, rb_str_new2 (r[i]));
2444     free (r[i]);
2445   }
2446   free (r);
2447   return rv;
2448 }
2449
2450 static VALUE ruby_guestfs_umount_all (VALUE gv)
2451 {
2452   guestfs_h *g;
2453   Data_Get_Struct (gv, guestfs_h, g);
2454   if (!g)
2455     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
2456
2457
2458   int r;
2459
2460   r = guestfs_umount_all (g);
2461   if (r == -1)
2462     rb_raise (e_Error, "%s", guestfs_last_error (g));
2463
2464   return Qnil;
2465 }
2466
2467 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
2468 {
2469   guestfs_h *g;
2470   Data_Get_Struct (gv, guestfs_h, g);
2471   if (!g)
2472     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
2473
2474
2475   int r;
2476
2477   r = guestfs_lvm_remove_all (g);
2478   if (r == -1)
2479     rb_raise (e_Error, "%s", guestfs_last_error (g));
2480
2481   return Qnil;
2482 }
2483
2484 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
2485 {
2486   guestfs_h *g;
2487   Data_Get_Struct (gv, guestfs_h, g);
2488   if (!g)
2489     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
2490
2491   const char *path = StringValueCStr (pathv);
2492   if (!path)
2493     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2494               "path", "file");
2495
2496   char *r;
2497
2498   r = guestfs_file (g, path);
2499   if (r == NULL)
2500     rb_raise (e_Error, "%s", guestfs_last_error (g));
2501
2502   VALUE rv = rb_str_new2 (r);
2503   free (r);
2504   return rv;
2505 }
2506
2507 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
2508 {
2509   guestfs_h *g;
2510   Data_Get_Struct (gv, guestfs_h, g);
2511   if (!g)
2512     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
2513
2514   char **arguments;  {
2515     int i, len;
2516     len = RARRAY_LEN (argumentsv);
2517     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2518     for (i = 0; i < len; ++i) {
2519       VALUE v = rb_ary_entry (argumentsv, i);
2520       arguments[i] = StringValueCStr (v);
2521     }
2522     arguments[len] = NULL;
2523   }
2524
2525   char *r;
2526
2527   r = guestfs_command (g, arguments);
2528   free (arguments);
2529   if (r == NULL)
2530     rb_raise (e_Error, "%s", guestfs_last_error (g));
2531
2532   VALUE rv = rb_str_new2 (r);
2533   free (r);
2534   return rv;
2535 }
2536
2537 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
2538 {
2539   guestfs_h *g;
2540   Data_Get_Struct (gv, guestfs_h, g);
2541   if (!g)
2542     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
2543
2544   char **arguments;  {
2545     int i, len;
2546     len = RARRAY_LEN (argumentsv);
2547     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2548     for (i = 0; i < len; ++i) {
2549       VALUE v = rb_ary_entry (argumentsv, i);
2550       arguments[i] = StringValueCStr (v);
2551     }
2552     arguments[len] = NULL;
2553   }
2554
2555   char **r;
2556
2557   r = guestfs_command_lines (g, arguments);
2558   free (arguments);
2559   if (r == NULL)
2560     rb_raise (e_Error, "%s", guestfs_last_error (g));
2561
2562   int i, len = 0;
2563   for (i = 0; r[i] != NULL; ++i) len++;
2564   VALUE rv = rb_ary_new2 (len);
2565   for (i = 0; r[i] != NULL; ++i) {
2566     rb_ary_push (rv, rb_str_new2 (r[i]));
2567     free (r[i]);
2568   }
2569   free (r);
2570   return rv;
2571 }
2572
2573 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
2574 {
2575   guestfs_h *g;
2576   Data_Get_Struct (gv, guestfs_h, g);
2577   if (!g)
2578     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
2579
2580   const char *path = StringValueCStr (pathv);
2581   if (!path)
2582     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2583               "path", "stat");
2584
2585   struct guestfs_stat *r;
2586
2587   r = guestfs_stat (g, path);
2588   if (r == NULL)
2589     rb_raise (e_Error, "%s", guestfs_last_error (g));
2590
2591   VALUE rv = rb_hash_new ();
2592   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2593   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2594   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2595   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2596   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2597   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2598   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2599   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2600   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2601   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2602   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2603   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2604   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2605   free (r);
2606   return rv;
2607 }
2608
2609 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
2610 {
2611   guestfs_h *g;
2612   Data_Get_Struct (gv, guestfs_h, g);
2613   if (!g)
2614     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
2615
2616   const char *path = StringValueCStr (pathv);
2617   if (!path)
2618     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2619               "path", "lstat");
2620
2621   struct guestfs_stat *r;
2622
2623   r = guestfs_lstat (g, path);
2624   if (r == NULL)
2625     rb_raise (e_Error, "%s", guestfs_last_error (g));
2626
2627   VALUE rv = rb_hash_new ();
2628   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
2629   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
2630   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
2631   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
2632   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
2633   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
2634   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
2635   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
2636   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
2637   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2638   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
2639   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
2640   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
2641   free (r);
2642   return rv;
2643 }
2644
2645 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
2646 {
2647   guestfs_h *g;
2648   Data_Get_Struct (gv, guestfs_h, g);
2649   if (!g)
2650     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
2651
2652   const char *path = StringValueCStr (pathv);
2653   if (!path)
2654     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2655               "path", "statvfs");
2656
2657   struct guestfs_statvfs *r;
2658
2659   r = guestfs_statvfs (g, path);
2660   if (r == NULL)
2661     rb_raise (e_Error, "%s", guestfs_last_error (g));
2662
2663   VALUE rv = rb_hash_new ();
2664   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
2665   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
2666   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
2667   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
2668   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
2669   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
2670   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
2671   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
2672   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
2673   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
2674   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
2675   free (r);
2676   return rv;
2677 }
2678
2679 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
2680 {
2681   guestfs_h *g;
2682   Data_Get_Struct (gv, guestfs_h, g);
2683   if (!g)
2684     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
2685
2686   const char *device = StringValueCStr (devicev);
2687   if (!device)
2688     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2689               "device", "tune2fs_l");
2690
2691   char **r;
2692
2693   r = guestfs_tune2fs_l (g, device);
2694   if (r == NULL)
2695     rb_raise (e_Error, "%s", guestfs_last_error (g));
2696
2697   VALUE rv = rb_hash_new ();
2698   int i;
2699   for (i = 0; r[i] != NULL; i+=2) {
2700     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
2701     free (r[i]);
2702     free (r[i+1]);
2703   }
2704   free (r);
2705   return rv;
2706 }
2707
2708 static VALUE ruby_guestfs_blockdev_setro (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_setro");
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_setro");
2719
2720   int r;
2721
2722   r = guestfs_blockdev_setro (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_setrw (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_setrw");
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_setrw");
2740
2741   int r;
2742
2743   r = guestfs_blockdev_setrw (g, device);
2744   if (r == -1)
2745     rb_raise (e_Error, "%s", guestfs_last_error (g));
2746
2747   return Qnil;
2748 }
2749
2750 static VALUE ruby_guestfs_blockdev_getro (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_getro");
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_getro");
2761
2762   int r;
2763
2764   r = guestfs_blockdev_getro (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_getss (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_getss");
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_getss");
2782
2783   int r;
2784
2785   r = guestfs_blockdev_getss (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_getbsz (VALUE gv, VALUE devicev)
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_getbsz");
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_getbsz");
2803
2804   int r;
2805
2806   r = guestfs_blockdev_getbsz (g, device);
2807   if (r == -1)
2808     rb_raise (e_Error, "%s", guestfs_last_error (g));
2809
2810   return INT2NUM (r);
2811 }
2812
2813 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2814 {
2815   guestfs_h *g;
2816   Data_Get_Struct (gv, guestfs_h, g);
2817   if (!g)
2818     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2819
2820   const char *device = StringValueCStr (devicev);
2821   if (!device)
2822     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2823               "device", "blockdev_setbsz");
2824   int blocksize = NUM2INT (blocksizev);
2825
2826   int r;
2827
2828   r = guestfs_blockdev_setbsz (g, device, blocksize);
2829   if (r == -1)
2830     rb_raise (e_Error, "%s", guestfs_last_error (g));
2831
2832   return Qnil;
2833 }
2834
2835 static VALUE ruby_guestfs_blockdev_getsz (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_getsz");
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_getsz");
2846
2847   int64_t r;
2848
2849   r = guestfs_blockdev_getsz (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_getsize64 (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_getsize64");
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_getsize64");
2867
2868   int64_t r;
2869
2870   r = guestfs_blockdev_getsize64 (g, device);
2871   if (r == -1)
2872     rb_raise (e_Error, "%s", guestfs_last_error (g));
2873
2874   return ULL2NUM (r);
2875 }
2876
2877 static VALUE ruby_guestfs_blockdev_flushbufs (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_flushbufs");
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_flushbufs");
2888
2889   int r;
2890
2891   r = guestfs_blockdev_flushbufs (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_blockdev_rereadpt (VALUE gv, VALUE devicev)
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", "blockdev_rereadpt");
2904
2905   const char *device = StringValueCStr (devicev);
2906   if (!device)
2907     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2908               "device", "blockdev_rereadpt");
2909
2910   int r;
2911
2912   r = guestfs_blockdev_rereadpt (g, device);
2913   if (r == -1)
2914     rb_raise (e_Error, "%s", guestfs_last_error (g));
2915
2916   return Qnil;
2917 }
2918
2919 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2920 {
2921   guestfs_h *g;
2922   Data_Get_Struct (gv, guestfs_h, g);
2923   if (!g)
2924     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2925
2926   const char *filename = StringValueCStr (filenamev);
2927   if (!filename)
2928     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2929               "filename", "upload");
2930   const char *remotefilename = StringValueCStr (remotefilenamev);
2931   if (!remotefilename)
2932     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2933               "remotefilename", "upload");
2934
2935   int r;
2936
2937   r = guestfs_upload (g, filename, remotefilename);
2938   if (r == -1)
2939     rb_raise (e_Error, "%s", guestfs_last_error (g));
2940
2941   return Qnil;
2942 }
2943
2944 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2945 {
2946   guestfs_h *g;
2947   Data_Get_Struct (gv, guestfs_h, g);
2948   if (!g)
2949     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2950
2951   const char *remotefilename = StringValueCStr (remotefilenamev);
2952   if (!remotefilename)
2953     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2954               "remotefilename", "download");
2955   const char *filename = StringValueCStr (filenamev);
2956   if (!filename)
2957     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2958               "filename", "download");
2959
2960   int r;
2961
2962   r = guestfs_download (g, remotefilename, filename);
2963   if (r == -1)
2964     rb_raise (e_Error, "%s", guestfs_last_error (g));
2965
2966   return Qnil;
2967 }
2968
2969 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2970 {
2971   guestfs_h *g;
2972   Data_Get_Struct (gv, guestfs_h, g);
2973   if (!g)
2974     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2975
2976   const char *csumtype = StringValueCStr (csumtypev);
2977   if (!csumtype)
2978     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2979               "csumtype", "checksum");
2980   const char *path = StringValueCStr (pathv);
2981   if (!path)
2982     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2983               "path", "checksum");
2984
2985   char *r;
2986
2987   r = guestfs_checksum (g, csumtype, path);
2988   if (r == NULL)
2989     rb_raise (e_Error, "%s", guestfs_last_error (g));
2990
2991   VALUE rv = rb_str_new2 (r);
2992   free (r);
2993   return rv;
2994 }
2995
2996 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2997 {
2998   guestfs_h *g;
2999   Data_Get_Struct (gv, guestfs_h, g);
3000   if (!g)
3001     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
3002
3003   const char *tarfile = StringValueCStr (tarfilev);
3004   if (!tarfile)
3005     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3006               "tarfile", "tar_in");
3007   const char *directory = StringValueCStr (directoryv);
3008   if (!directory)
3009     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3010               "directory", "tar_in");
3011
3012   int r;
3013
3014   r = guestfs_tar_in (g, tarfile, directory);
3015   if (r == -1)
3016     rb_raise (e_Error, "%s", guestfs_last_error (g));
3017
3018   return Qnil;
3019 }
3020
3021 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
3022 {
3023   guestfs_h *g;
3024   Data_Get_Struct (gv, guestfs_h, g);
3025   if (!g)
3026     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
3027
3028   const char *directory = StringValueCStr (directoryv);
3029   if (!directory)
3030     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3031               "directory", "tar_out");
3032   const char *tarfile = StringValueCStr (tarfilev);
3033   if (!tarfile)
3034     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3035               "tarfile", "tar_out");
3036
3037   int r;
3038
3039   r = guestfs_tar_out (g, directory, tarfile);
3040   if (r == -1)
3041     rb_raise (e_Error, "%s", guestfs_last_error (g));
3042
3043   return Qnil;
3044 }
3045
3046 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
3047 {
3048   guestfs_h *g;
3049   Data_Get_Struct (gv, guestfs_h, g);
3050   if (!g)
3051     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
3052
3053   const char *tarball = StringValueCStr (tarballv);
3054   if (!tarball)
3055     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3056               "tarball", "tgz_in");
3057   const char *directory = StringValueCStr (directoryv);
3058   if (!directory)
3059     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3060               "directory", "tgz_in");
3061
3062   int r;
3063
3064   r = guestfs_tgz_in (g, tarball, directory);
3065   if (r == -1)
3066     rb_raise (e_Error, "%s", guestfs_last_error (g));
3067
3068   return Qnil;
3069 }
3070
3071 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
3072 {
3073   guestfs_h *g;
3074   Data_Get_Struct (gv, guestfs_h, g);
3075   if (!g)
3076     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
3077
3078   const char *directory = StringValueCStr (directoryv);
3079   if (!directory)
3080     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3081               "directory", "tgz_out");
3082   const char *tarball = StringValueCStr (tarballv);
3083   if (!tarball)
3084     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3085               "tarball", "tgz_out");
3086
3087   int r;
3088
3089   r = guestfs_tgz_out (g, directory, tarball);
3090   if (r == -1)
3091     rb_raise (e_Error, "%s", guestfs_last_error (g));
3092
3093   return Qnil;
3094 }
3095
3096 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
3097 {
3098   guestfs_h *g;
3099   Data_Get_Struct (gv, guestfs_h, g);
3100   if (!g)
3101     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
3102
3103   const char *device = StringValueCStr (devicev);
3104   if (!device)
3105     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3106               "device", "mount_ro");
3107   const char *mountpoint = StringValueCStr (mountpointv);
3108   if (!mountpoint)
3109     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3110               "mountpoint", "mount_ro");
3111
3112   int r;
3113
3114   r = guestfs_mount_ro (g, device, mountpoint);
3115   if (r == -1)
3116     rb_raise (e_Error, "%s", guestfs_last_error (g));
3117
3118   return Qnil;
3119 }
3120
3121 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
3122 {
3123   guestfs_h *g;
3124   Data_Get_Struct (gv, guestfs_h, g);
3125   if (!g)
3126     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
3127
3128   const char *options = StringValueCStr (optionsv);
3129   if (!options)
3130     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3131               "options", "mount_options");
3132   const char *device = StringValueCStr (devicev);
3133   if (!device)
3134     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3135               "device", "mount_options");
3136   const char *mountpoint = StringValueCStr (mountpointv);
3137   if (!mountpoint)
3138     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3139               "mountpoint", "mount_options");
3140
3141   int r;
3142
3143   r = guestfs_mount_options (g, options, device, mountpoint);
3144   if (r == -1)
3145     rb_raise (e_Error, "%s", guestfs_last_error (g));
3146
3147   return Qnil;
3148 }
3149
3150 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
3151 {
3152   guestfs_h *g;
3153   Data_Get_Struct (gv, guestfs_h, g);
3154   if (!g)
3155     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
3156
3157   const char *options = StringValueCStr (optionsv);
3158   if (!options)
3159     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3160               "options", "mount_vfs");
3161   const char *vfstype = StringValueCStr (vfstypev);
3162   if (!vfstype)
3163     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3164               "vfstype", "mount_vfs");
3165   const char *device = StringValueCStr (devicev);
3166   if (!device)
3167     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3168               "device", "mount_vfs");
3169   const char *mountpoint = StringValueCStr (mountpointv);
3170   if (!mountpoint)
3171     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3172               "mountpoint", "mount_vfs");
3173
3174   int r;
3175
3176   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3177   if (r == -1)
3178     rb_raise (e_Error, "%s", guestfs_last_error (g));
3179
3180   return Qnil;
3181 }
3182
3183 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
3184 {
3185   guestfs_h *g;
3186   Data_Get_Struct (gv, guestfs_h, g);
3187   if (!g)
3188     rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
3189
3190   const char *subcmd = StringValueCStr (subcmdv);
3191   if (!subcmd)
3192     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3193               "subcmd", "debug");
3194   char **extraargs;  {
3195     int i, len;
3196     len = RARRAY_LEN (extraargsv);
3197     extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3198     for (i = 0; i < len; ++i) {
3199       VALUE v = rb_ary_entry (extraargsv, i);
3200       extraargs[i] = StringValueCStr (v);
3201     }
3202     extraargs[len] = NULL;
3203   }
3204
3205   char *r;
3206
3207   r = guestfs_debug (g, subcmd, extraargs);
3208   free (extraargs);
3209   if (r == NULL)
3210     rb_raise (e_Error, "%s", guestfs_last_error (g));
3211
3212   VALUE rv = rb_str_new2 (r);
3213   free (r);
3214   return rv;
3215 }
3216
3217 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
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", "lvremove");
3223
3224   const char *device = StringValueCStr (devicev);
3225   if (!device)
3226     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3227               "device", "lvremove");
3228
3229   int r;
3230
3231   r = guestfs_lvremove (g, device);
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_vgremove (VALUE gv, VALUE vgnamev)
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", "vgremove");
3244
3245   const char *vgname = StringValueCStr (vgnamev);
3246   if (!vgname)
3247     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3248               "vgname", "vgremove");
3249
3250   int r;
3251
3252   r = guestfs_vgremove (g, vgname);
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_pvremove (VALUE gv, VALUE devicev)
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", "pvremove");
3265
3266   const char *device = StringValueCStr (devicev);
3267   if (!device)
3268     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3269               "device", "pvremove");
3270
3271   int r;
3272
3273   r = guestfs_pvremove (g, device);
3274   if (r == -1)
3275     rb_raise (e_Error, "%s", guestfs_last_error (g));
3276
3277   return Qnil;
3278 }
3279
3280 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
3281 {
3282   guestfs_h *g;
3283   Data_Get_Struct (gv, guestfs_h, g);
3284   if (!g)
3285     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
3286
3287   const char *device = StringValueCStr (devicev);
3288   if (!device)
3289     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3290               "device", "set_e2label");
3291   const char *label = StringValueCStr (labelv);
3292   if (!label)
3293     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3294               "label", "set_e2label");
3295
3296   int r;
3297
3298   r = guestfs_set_e2label (g, device, label);
3299   if (r == -1)
3300     rb_raise (e_Error, "%s", guestfs_last_error (g));
3301
3302   return Qnil;
3303 }
3304
3305 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
3306 {
3307   guestfs_h *g;
3308   Data_Get_Struct (gv, guestfs_h, g);
3309   if (!g)
3310     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
3311
3312   const char *device = StringValueCStr (devicev);
3313   if (!device)
3314     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3315               "device", "get_e2label");
3316
3317   char *r;
3318
3319   r = guestfs_get_e2label (g, device);
3320   if (r == NULL)
3321     rb_raise (e_Error, "%s", guestfs_last_error (g));
3322
3323   VALUE rv = rb_str_new2 (r);
3324   free (r);
3325   return rv;
3326 }
3327
3328 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
3329 {
3330   guestfs_h *g;
3331   Data_Get_Struct (gv, guestfs_h, g);
3332   if (!g)
3333     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
3334
3335   const char *device = StringValueCStr (devicev);
3336   if (!device)
3337     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3338               "device", "set_e2uuid");
3339   const char *uuid = StringValueCStr (uuidv);
3340   if (!uuid)
3341     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3342               "uuid", "set_e2uuid");
3343
3344   int r;
3345
3346   r = guestfs_set_e2uuid (g, device, uuid);
3347   if (r == -1)
3348     rb_raise (e_Error, "%s", guestfs_last_error (g));
3349
3350   return Qnil;
3351 }
3352
3353 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
3354 {
3355   guestfs_h *g;
3356   Data_Get_Struct (gv, guestfs_h, g);
3357   if (!g)
3358     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
3359
3360   const char *device = StringValueCStr (devicev);
3361   if (!device)
3362     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3363               "device", "get_e2uuid");
3364
3365   char *r;
3366
3367   r = guestfs_get_e2uuid (g, device);
3368   if (r == NULL)
3369     rb_raise (e_Error, "%s", guestfs_last_error (g));
3370
3371   VALUE rv = rb_str_new2 (r);
3372   free (r);
3373   return rv;
3374 }
3375
3376 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
3377 {
3378   guestfs_h *g;
3379   Data_Get_Struct (gv, guestfs_h, g);
3380   if (!g)
3381     rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
3382
3383   const char *fstype = StringValueCStr (fstypev);
3384   if (!fstype)
3385     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3386               "fstype", "fsck");
3387   const char *device = StringValueCStr (devicev);
3388   if (!device)
3389     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3390               "device", "fsck");
3391
3392   int r;
3393
3394   r = guestfs_fsck (g, fstype, device);
3395   if (r == -1)
3396     rb_raise (e_Error, "%s", guestfs_last_error (g));
3397
3398   return INT2NUM (r);
3399 }
3400
3401 static VALUE ruby_guestfs_zero (VALUE gv, 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", "zero");
3407
3408   const char *device = StringValueCStr (devicev);
3409   if (!device)
3410     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3411               "device", "zero");
3412
3413   int r;
3414
3415   r = guestfs_zero (g, device);
3416   if (r == -1)
3417     rb_raise (e_Error, "%s", guestfs_last_error (g));
3418
3419   return Qnil;
3420 }
3421
3422 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
3423 {
3424   guestfs_h *g;
3425   Data_Get_Struct (gv, guestfs_h, g);
3426   if (!g)
3427     rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
3428
3429   const char *root = StringValueCStr (rootv);
3430   if (!root)
3431     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3432               "root", "grub_install");
3433   const char *device = StringValueCStr (devicev);
3434   if (!device)
3435     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3436               "device", "grub_install");
3437
3438   int r;
3439
3440   r = guestfs_grub_install (g, root, device);
3441   if (r == -1)
3442     rb_raise (e_Error, "%s", guestfs_last_error (g));
3443
3444   return Qnil;
3445 }
3446
3447 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
3448 {
3449   guestfs_h *g;
3450   Data_Get_Struct (gv, guestfs_h, g);
3451   if (!g)
3452     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
3453
3454   const char *src = StringValueCStr (srcv);
3455   if (!src)
3456     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3457               "src", "cp");
3458   const char *dest = StringValueCStr (destv);
3459   if (!dest)
3460     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3461               "dest", "cp");
3462
3463   int r;
3464
3465   r = guestfs_cp (g, src, dest);
3466   if (r == -1)
3467     rb_raise (e_Error, "%s", guestfs_last_error (g));
3468
3469   return Qnil;
3470 }
3471
3472 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
3473 {
3474   guestfs_h *g;
3475   Data_Get_Struct (gv, guestfs_h, g);
3476   if (!g)
3477     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
3478
3479   const char *src = StringValueCStr (srcv);
3480   if (!src)
3481     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3482               "src", "cp_a");
3483   const char *dest = StringValueCStr (destv);
3484   if (!dest)
3485     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3486               "dest", "cp_a");
3487
3488   int r;
3489
3490   r = guestfs_cp_a (g, src, dest);
3491   if (r == -1)
3492     rb_raise (e_Error, "%s", guestfs_last_error (g));
3493
3494   return Qnil;
3495 }
3496
3497 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
3498 {
3499   guestfs_h *g;
3500   Data_Get_Struct (gv, guestfs_h, g);
3501   if (!g)
3502     rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
3503
3504   const char *src = StringValueCStr (srcv);
3505   if (!src)
3506     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3507               "src", "mv");
3508   const char *dest = StringValueCStr (destv);
3509   if (!dest)
3510     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3511               "dest", "mv");
3512
3513   int r;
3514
3515   r = guestfs_mv (g, src, dest);
3516   if (r == -1)
3517     rb_raise (e_Error, "%s", guestfs_last_error (g));
3518
3519   return Qnil;
3520 }
3521
3522 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
3523 {
3524   guestfs_h *g;
3525   Data_Get_Struct (gv, guestfs_h, g);
3526   if (!g)
3527     rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
3528
3529   int whattodrop = NUM2INT (whattodropv);
3530
3531   int r;
3532
3533   r = guestfs_drop_caches (g, whattodrop);
3534   if (r == -1)
3535     rb_raise (e_Error, "%s", guestfs_last_error (g));
3536
3537   return Qnil;
3538 }
3539
3540 static VALUE ruby_guestfs_dmesg (VALUE gv)
3541 {
3542   guestfs_h *g;
3543   Data_Get_Struct (gv, guestfs_h, g);
3544   if (!g)
3545     rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
3546
3547
3548   char *r;
3549
3550   r = guestfs_dmesg (g);
3551   if (r == NULL)
3552     rb_raise (e_Error, "%s", guestfs_last_error (g));
3553
3554   VALUE rv = rb_str_new2 (r);
3555   free (r);
3556   return rv;
3557 }
3558
3559 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
3560 {
3561   guestfs_h *g;
3562   Data_Get_Struct (gv, guestfs_h, g);
3563   if (!g)
3564     rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
3565
3566
3567   int r;
3568
3569   r = guestfs_ping_daemon (g);
3570   if (r == -1)
3571     rb_raise (e_Error, "%s", guestfs_last_error (g));
3572
3573   return Qnil;
3574 }
3575
3576 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
3577 {
3578   guestfs_h *g;
3579   Data_Get_Struct (gv, guestfs_h, g);
3580   if (!g)
3581     rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
3582
3583   const char *file1 = StringValueCStr (file1v);
3584   if (!file1)
3585     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3586               "file1", "equal");
3587   const char *file2 = StringValueCStr (file2v);
3588   if (!file2)
3589     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3590               "file2", "equal");
3591
3592   int r;
3593
3594   r = guestfs_equal (g, file1, file2);
3595   if (r == -1)
3596     rb_raise (e_Error, "%s", guestfs_last_error (g));
3597
3598   return INT2NUM (r);
3599 }
3600
3601 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
3602 {
3603   guestfs_h *g;
3604   Data_Get_Struct (gv, guestfs_h, g);
3605   if (!g)
3606     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
3607
3608   const char *path = StringValueCStr (pathv);
3609   if (!path)
3610     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3611               "path", "strings");
3612
3613   char **r;
3614
3615   r = guestfs_strings (g, path);
3616   if (r == NULL)
3617     rb_raise (e_Error, "%s", guestfs_last_error (g));
3618
3619   int i, len = 0;
3620   for (i = 0; r[i] != NULL; ++i) len++;
3621   VALUE rv = rb_ary_new2 (len);
3622   for (i = 0; r[i] != NULL; ++i) {
3623     rb_ary_push (rv, rb_str_new2 (r[i]));
3624     free (r[i]);
3625   }
3626   free (r);
3627   return rv;
3628 }
3629
3630 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
3631 {
3632   guestfs_h *g;
3633   Data_Get_Struct (gv, guestfs_h, g);
3634   if (!g)
3635     rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
3636
3637   const char *encoding = StringValueCStr (encodingv);
3638   if (!encoding)
3639     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3640               "encoding", "strings_e");
3641   const char *path = StringValueCStr (pathv);
3642   if (!path)
3643     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3644               "path", "strings_e");
3645
3646   char **r;
3647
3648   r = guestfs_strings_e (g, encoding, path);
3649   if (r == NULL)
3650     rb_raise (e_Error, "%s", guestfs_last_error (g));
3651
3652   int i, len = 0;
3653   for (i = 0; r[i] != NULL; ++i) len++;
3654   VALUE rv = rb_ary_new2 (len);
3655   for (i = 0; r[i] != NULL; ++i) {
3656     rb_ary_push (rv, rb_str_new2 (r[i]));
3657     free (r[i]);
3658   }
3659   free (r);
3660   return rv;
3661 }
3662
3663 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
3664 {
3665   guestfs_h *g;
3666   Data_Get_Struct (gv, guestfs_h, g);
3667   if (!g)
3668     rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
3669
3670   const char *path = StringValueCStr (pathv);
3671   if (!path)
3672     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3673               "path", "hexdump");
3674
3675   char *r;
3676
3677   r = guestfs_hexdump (g, path);
3678   if (r == NULL)
3679     rb_raise (e_Error, "%s", guestfs_last_error (g));
3680
3681   VALUE rv = rb_str_new2 (r);
3682   free (r);
3683   return rv;
3684 }
3685
3686 static VALUE ruby_guestfs_zerofree (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", "zerofree");
3692
3693   const char *device = StringValueCStr (devicev);
3694   if (!device)
3695     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3696               "device", "zerofree");
3697
3698   int r;
3699
3700   r = guestfs_zerofree (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_pvresize (VALUE gv, VALUE devicev)
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", "pvresize");
3713
3714   const char *device = StringValueCStr (devicev);
3715   if (!device)
3716     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3717               "device", "pvresize");
3718
3719   int r;
3720
3721   r = guestfs_pvresize (g, device);
3722   if (r == -1)
3723     rb_raise (e_Error, "%s", guestfs_last_error (g));
3724
3725   return Qnil;
3726 }
3727
3728 static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE nv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev)
3729 {
3730   guestfs_h *g;
3731   Data_Get_Struct (gv, guestfs_h, g);
3732   if (!g)
3733     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
3734
3735   const char *device = StringValueCStr (devicev);
3736   if (!device)
3737     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3738               "device", "sfdisk_N");
3739   int n = NUM2INT (nv);
3740   int cyls = NUM2INT (cylsv);
3741   int heads = NUM2INT (headsv);
3742   int sectors = NUM2INT (sectorsv);
3743   const char *line = StringValueCStr (linev);
3744   if (!line)
3745     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3746               "line", "sfdisk_N");
3747
3748   int r;
3749
3750   r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
3751   if (r == -1)
3752     rb_raise (e_Error, "%s", guestfs_last_error (g));
3753
3754   return Qnil;
3755 }
3756
3757 static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
3758 {
3759   guestfs_h *g;
3760   Data_Get_Struct (gv, guestfs_h, g);
3761   if (!g)
3762     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
3763
3764   const char *device = StringValueCStr (devicev);
3765   if (!device)
3766     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3767               "device", "sfdisk_l");
3768
3769   char *r;
3770
3771   r = guestfs_sfdisk_l (g, device);
3772   if (r == NULL)
3773     rb_raise (e_Error, "%s", guestfs_last_error (g));
3774
3775   VALUE rv = rb_str_new2 (r);
3776   free (r);
3777   return rv;
3778 }
3779
3780 static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
3781 {
3782   guestfs_h *g;
3783   Data_Get_Struct (gv, guestfs_h, g);
3784   if (!g)
3785     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
3786
3787   const char *device = StringValueCStr (devicev);
3788   if (!device)
3789     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3790               "device", "sfdisk_kernel_geometry");
3791
3792   char *r;
3793
3794   r = guestfs_sfdisk_kernel_geometry (g, device);
3795   if (r == NULL)
3796     rb_raise (e_Error, "%s", guestfs_last_error (g));
3797
3798   VALUE rv = rb_str_new2 (r);
3799   free (r);
3800   return rv;
3801 }
3802
3803 static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
3804 {
3805   guestfs_h *g;
3806   Data_Get_Struct (gv, guestfs_h, g);
3807   if (!g)
3808     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
3809
3810   const char *device = StringValueCStr (devicev);
3811   if (!device)
3812     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3813               "device", "sfdisk_disk_geometry");
3814
3815   char *r;
3816
3817   r = guestfs_sfdisk_disk_geometry (g, device);
3818   if (r == NULL)
3819     rb_raise (e_Error, "%s", guestfs_last_error (g));
3820
3821   VALUE rv = rb_str_new2 (r);
3822   free (r);
3823   return rv;
3824 }
3825
3826 static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
3827 {
3828   guestfs_h *g;
3829   Data_Get_Struct (gv, guestfs_h, g);
3830   if (!g)
3831     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
3832
3833   int activate = RTEST (activatev);
3834
3835   int r;
3836
3837   r = guestfs_vg_activate_all (g, activate);
3838   if (r == -1)
3839     rb_raise (e_Error, "%s", guestfs_last_error (g));
3840
3841   return Qnil;
3842 }
3843
3844 static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv)
3845 {
3846   guestfs_h *g;
3847   Data_Get_Struct (gv, guestfs_h, g);
3848   if (!g)
3849     rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
3850
3851   int activate = RTEST (activatev);
3852   char **volgroups;  {
3853     int i, len;
3854     len = RARRAY_LEN (volgroupsv);
3855     volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3856     for (i = 0; i < len; ++i) {
3857       VALUE v = rb_ary_entry (volgroupsv, i);
3858       volgroups[i] = StringValueCStr (v);
3859     }
3860     volgroups[len] = NULL;
3861   }
3862
3863   int r;
3864
3865   r = guestfs_vg_activate (g, activate, volgroups);
3866   free (volgroups);
3867   if (r == -1)
3868     rb_raise (e_Error, "%s", guestfs_last_error (g));
3869
3870   return Qnil;
3871 }
3872
3873 static VALUE ruby_guestfs_lvresize (VALUE gv, VALUE devicev, VALUE mbytesv)
3874 {
3875   guestfs_h *g;
3876   Data_Get_Struct (gv, guestfs_h, g);
3877   if (!g)
3878     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize");
3879
3880   const char *device = StringValueCStr (devicev);
3881   if (!device)
3882     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3883               "device", "lvresize");
3884   int mbytes = NUM2INT (mbytesv);
3885
3886   int r;
3887
3888   r = guestfs_lvresize (g, device, mbytes);
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_resize2fs (VALUE gv, VALUE devicev)
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", "resize2fs");
3901
3902   const char *device = StringValueCStr (devicev);
3903   if (!device)
3904     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3905               "device", "resize2fs");
3906
3907   int r;
3908
3909   r = guestfs_resize2fs (g, device);
3910   if (r == -1)
3911     rb_raise (e_Error, "%s", guestfs_last_error (g));
3912
3913   return Qnil;
3914 }
3915
3916 static VALUE ruby_guestfs_find (VALUE gv, VALUE directoryv)
3917 {
3918   guestfs_h *g;
3919   Data_Get_Struct (gv, guestfs_h, g);
3920   if (!g)
3921     rb_raise (rb_eArgError, "%s: used handle after closing it", "find");
3922
3923   const char *directory = StringValueCStr (directoryv);
3924   if (!directory)
3925     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3926               "directory", "find");
3927
3928   char **r;
3929
3930   r = guestfs_find (g, directory);
3931   if (r == NULL)
3932     rb_raise (e_Error, "%s", guestfs_last_error (g));
3933
3934   int i, len = 0;
3935   for (i = 0; r[i] != NULL; ++i) len++;
3936   VALUE rv = rb_ary_new2 (len);
3937   for (i = 0; r[i] != NULL; ++i) {
3938     rb_ary_push (rv, rb_str_new2 (r[i]));
3939     free (r[i]);
3940   }
3941   free (r);
3942   return rv;
3943 }
3944
3945 static VALUE ruby_guestfs_e2fsck_f (VALUE gv, VALUE devicev)
3946 {
3947   guestfs_h *g;
3948   Data_Get_Struct (gv, guestfs_h, g);
3949   if (!g)
3950     rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f");
3951
3952   const char *device = StringValueCStr (devicev);
3953   if (!device)
3954     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3955               "device", "e2fsck_f");
3956
3957   int r;
3958
3959   r = guestfs_e2fsck_f (g, device);
3960   if (r == -1)
3961     rb_raise (e_Error, "%s", guestfs_last_error (g));
3962
3963   return Qnil;
3964 }
3965
3966 /* Initialize the module. */
3967 void Init__guestfs ()
3968 {
3969   m_guestfs = rb_define_module ("Guestfs");
3970   c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
3971   e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
3972
3973   rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
3974   rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
3975
3976   rb_define_method (c_guestfs, "test0",
3977         ruby_guestfs_test0, 7);
3978   rb_define_method (c_guestfs, "test0rint",
3979         ruby_guestfs_test0rint, 1);
3980   rb_define_method (c_guestfs, "test0rinterr",
3981         ruby_guestfs_test0rinterr, 0);
3982   rb_define_method (c_guestfs, "test0rint64",
3983         ruby_guestfs_test0rint64, 1);
3984   rb_define_method (c_guestfs, "test0rint64err",
3985         ruby_guestfs_test0rint64err, 0);
3986   rb_define_method (c_guestfs, "test0rbool",
3987         ruby_guestfs_test0rbool, 1);
3988   rb_define_method (c_guestfs, "test0rboolerr",
3989         ruby_guestfs_test0rboolerr, 0);
3990   rb_define_method (c_guestfs, "test0rconststring",
3991         ruby_guestfs_test0rconststring, 1);
3992   rb_define_method (c_guestfs, "test0rconststringerr",
3993         ruby_guestfs_test0rconststringerr, 0);
3994   rb_define_method (c_guestfs, "test0rstring",
3995         ruby_guestfs_test0rstring, 1);
3996   rb_define_method (c_guestfs, "test0rstringerr",
3997         ruby_guestfs_test0rstringerr, 0);
3998   rb_define_method (c_guestfs, "test0rstringlist",
3999         ruby_guestfs_test0rstringlist, 1);
4000   rb_define_method (c_guestfs, "test0rstringlisterr",
4001         ruby_guestfs_test0rstringlisterr, 0);
4002   rb_define_method (c_guestfs, "test0rintbool",
4003         ruby_guestfs_test0rintbool, 1);
4004   rb_define_method (c_guestfs, "test0rintboolerr",
4005         ruby_guestfs_test0rintboolerr, 0);
4006   rb_define_method (c_guestfs, "test0rpvlist",
4007         ruby_guestfs_test0rpvlist, 1);
4008   rb_define_method (c_guestfs, "test0rpvlisterr",
4009         ruby_guestfs_test0rpvlisterr, 0);
4010   rb_define_method (c_guestfs, "test0rvglist",
4011         ruby_guestfs_test0rvglist, 1);
4012   rb_define_method (c_guestfs, "test0rvglisterr",
4013         ruby_guestfs_test0rvglisterr, 0);
4014   rb_define_method (c_guestfs, "test0rlvlist",
4015         ruby_guestfs_test0rlvlist, 1);
4016   rb_define_method (c_guestfs, "test0rlvlisterr",
4017         ruby_guestfs_test0rlvlisterr, 0);
4018   rb_define_method (c_guestfs, "test0rstat",
4019         ruby_guestfs_test0rstat, 1);
4020   rb_define_method (c_guestfs, "test0rstaterr",
4021         ruby_guestfs_test0rstaterr, 0);
4022   rb_define_method (c_guestfs, "test0rstatvfs",
4023         ruby_guestfs_test0rstatvfs, 1);
4024   rb_define_method (c_guestfs, "test0rstatvfserr",
4025         ruby_guestfs_test0rstatvfserr, 0);
4026   rb_define_method (c_guestfs, "test0rhashtable",
4027         ruby_guestfs_test0rhashtable, 1);
4028   rb_define_method (c_guestfs, "test0rhashtableerr",
4029         ruby_guestfs_test0rhashtableerr, 0);
4030   rb_define_method (c_guestfs, "launch",
4031         ruby_guestfs_launch, 0);
4032   rb_define_method (c_guestfs, "wait_ready",
4033         ruby_guestfs_wait_ready, 0);
4034   rb_define_method (c_guestfs, "kill_subprocess",
4035         ruby_guestfs_kill_subprocess, 0);
4036   rb_define_method (c_guestfs, "add_drive",
4037         ruby_guestfs_add_drive, 1);
4038   rb_define_method (c_guestfs, "add_cdrom",
4039         ruby_guestfs_add_cdrom, 1);
4040   rb_define_method (c_guestfs, "add_drive_ro",
4041         ruby_guestfs_add_drive_ro, 1);
4042   rb_define_method (c_guestfs, "config",
4043         ruby_guestfs_config, 2);
4044   rb_define_method (c_guestfs, "set_qemu",
4045         ruby_guestfs_set_qemu, 1);
4046   rb_define_method (c_guestfs, "get_qemu",
4047         ruby_guestfs_get_qemu, 0);
4048   rb_define_method (c_guestfs, "set_path",
4049         ruby_guestfs_set_path, 1);
4050   rb_define_method (c_guestfs, "get_path",
4051         ruby_guestfs_get_path, 0);
4052   rb_define_method (c_guestfs, "set_append",
4053         ruby_guestfs_set_append, 1);
4054   rb_define_method (c_guestfs, "get_append",
4055         ruby_guestfs_get_append, 0);
4056   rb_define_method (c_guestfs, "set_autosync",
4057         ruby_guestfs_set_autosync, 1);
4058   rb_define_method (c_guestfs, "get_autosync",
4059         ruby_guestfs_get_autosync, 0);
4060   rb_define_method (c_guestfs, "set_verbose",
4061         ruby_guestfs_set_verbose, 1);
4062   rb_define_method (c_guestfs, "get_verbose",
4063         ruby_guestfs_get_verbose, 0);
4064   rb_define_method (c_guestfs, "is_ready",
4065         ruby_guestfs_is_ready, 0);
4066   rb_define_method (c_guestfs, "is_config",
4067         ruby_guestfs_is_config, 0);
4068   rb_define_method (c_guestfs, "is_launching",
4069         ruby_guestfs_is_launching, 0);
4070   rb_define_method (c_guestfs, "is_busy",
4071         ruby_guestfs_is_busy, 0);
4072   rb_define_method (c_guestfs, "get_state",
4073         ruby_guestfs_get_state, 0);
4074   rb_define_method (c_guestfs, "set_busy",
4075         ruby_guestfs_set_busy, 0);
4076   rb_define_method (c_guestfs, "set_ready",
4077         ruby_guestfs_set_ready, 0);
4078   rb_define_method (c_guestfs, "end_busy",
4079         ruby_guestfs_end_busy, 0);
4080   rb_define_method (c_guestfs, "mount",
4081         ruby_guestfs_mount, 2);
4082   rb_define_method (c_guestfs, "sync",
4083         ruby_guestfs_sync, 0);
4084   rb_define_method (c_guestfs, "touch",
4085         ruby_guestfs_touch, 1);
4086   rb_define_method (c_guestfs, "cat",
4087         ruby_guestfs_cat, 1);
4088   rb_define_method (c_guestfs, "ll",
4089         ruby_guestfs_ll, 1);
4090   rb_define_method (c_guestfs, "ls",
4091         ruby_guestfs_ls, 1);
4092   rb_define_method (c_guestfs, "list_devices",
4093         ruby_guestfs_list_devices, 0);
4094   rb_define_method (c_guestfs, "list_partitions",
4095         ruby_guestfs_list_partitions, 0);
4096   rb_define_method (c_guestfs, "pvs",
4097         ruby_guestfs_pvs, 0);
4098   rb_define_method (c_guestfs, "vgs",
4099         ruby_guestfs_vgs, 0);
4100   rb_define_method (c_guestfs, "lvs",
4101         ruby_guestfs_lvs, 0);
4102   rb_define_method (c_guestfs, "pvs_full",
4103         ruby_guestfs_pvs_full, 0);
4104   rb_define_method (c_guestfs, "vgs_full",
4105         ruby_guestfs_vgs_full, 0);
4106   rb_define_method (c_guestfs, "lvs_full",
4107         ruby_guestfs_lvs_full, 0);
4108   rb_define_method (c_guestfs, "read_lines",
4109         ruby_guestfs_read_lines, 1);
4110   rb_define_method (c_guestfs, "aug_init",
4111         ruby_guestfs_aug_init, 2);
4112   rb_define_method (c_guestfs, "aug_close",
4113         ruby_guestfs_aug_close, 0);
4114   rb_define_method (c_guestfs, "aug_defvar",
4115         ruby_guestfs_aug_defvar, 2);
4116   rb_define_method (c_guestfs, "aug_defnode",
4117         ruby_guestfs_aug_defnode, 3);
4118   rb_define_method (c_guestfs, "aug_get",
4119         ruby_guestfs_aug_get, 1);
4120   rb_define_method (c_guestfs, "aug_set",
4121         ruby_guestfs_aug_set, 2);
4122   rb_define_method (c_guestfs, "aug_insert",
4123         ruby_guestfs_aug_insert, 3);
4124   rb_define_method (c_guestfs, "aug_rm",
4125         ruby_guestfs_aug_rm, 1);
4126   rb_define_method (c_guestfs, "aug_mv",
4127         ruby_guestfs_aug_mv, 2);
4128   rb_define_method (c_guestfs, "aug_match",
4129         ruby_guestfs_aug_match, 1);
4130   rb_define_method (c_guestfs, "aug_save",
4131         ruby_guestfs_aug_save, 0);
4132   rb_define_method (c_guestfs, "aug_load",
4133         ruby_guestfs_aug_load, 0);
4134   rb_define_method (c_guestfs, "aug_ls",
4135         ruby_guestfs_aug_ls, 1);
4136   rb_define_method (c_guestfs, "rm",
4137         ruby_guestfs_rm, 1);
4138   rb_define_method (c_guestfs, "rmdir",
4139         ruby_guestfs_rmdir, 1);
4140   rb_define_method (c_guestfs, "rm_rf",
4141         ruby_guestfs_rm_rf, 1);
4142   rb_define_method (c_guestfs, "mkdir",
4143         ruby_guestfs_mkdir, 1);
4144   rb_define_method (c_guestfs, "mkdir_p",
4145         ruby_guestfs_mkdir_p, 1);
4146   rb_define_method (c_guestfs, "chmod",
4147         ruby_guestfs_chmod, 2);
4148   rb_define_method (c_guestfs, "chown",
4149         ruby_guestfs_chown, 3);
4150   rb_define_method (c_guestfs, "exists",
4151         ruby_guestfs_exists, 1);
4152   rb_define_method (c_guestfs, "is_file",
4153         ruby_guestfs_is_file, 1);
4154   rb_define_method (c_guestfs, "is_dir",
4155         ruby_guestfs_is_dir, 1);
4156   rb_define_method (c_guestfs, "pvcreate",
4157         ruby_guestfs_pvcreate, 1);
4158   rb_define_method (c_guestfs, "vgcreate",
4159         ruby_guestfs_vgcreate, 2);
4160   rb_define_method (c_guestfs, "lvcreate",
4161         ruby_guestfs_lvcreate, 3);
4162   rb_define_method (c_guestfs, "mkfs",
4163         ruby_guestfs_mkfs, 2);
4164   rb_define_method (c_guestfs, "sfdisk",
4165         ruby_guestfs_sfdisk, 5);
4166   rb_define_method (c_guestfs, "write_file",
4167         ruby_guestfs_write_file, 3);
4168   rb_define_method (c_guestfs, "umount",
4169         ruby_guestfs_umount, 1);
4170   rb_define_method (c_guestfs, "mounts",
4171         ruby_guestfs_mounts, 0);
4172   rb_define_method (c_guestfs, "umount_all",
4173         ruby_guestfs_umount_all, 0);
4174   rb_define_method (c_guestfs, "lvm_remove_all",
4175         ruby_guestfs_lvm_remove_all, 0);
4176   rb_define_method (c_guestfs, "file",
4177         ruby_guestfs_file, 1);
4178   rb_define_method (c_guestfs, "command",
4179         ruby_guestfs_command, 1);
4180   rb_define_method (c_guestfs, "command_lines",
4181         ruby_guestfs_command_lines, 1);
4182   rb_define_method (c_guestfs, "stat",
4183         ruby_guestfs_stat, 1);
4184   rb_define_method (c_guestfs, "lstat",
4185         ruby_guestfs_lstat, 1);
4186   rb_define_method (c_guestfs, "statvfs",
4187         ruby_guestfs_statvfs, 1);
4188   rb_define_method (c_guestfs, "tune2fs_l",
4189         ruby_guestfs_tune2fs_l, 1);
4190   rb_define_method (c_guestfs, "blockdev_setro",
4191         ruby_guestfs_blockdev_setro, 1);
4192   rb_define_method (c_guestfs, "blockdev_setrw",
4193         ruby_guestfs_blockdev_setrw, 1);
4194   rb_define_method (c_guestfs, "blockdev_getro",
4195         ruby_guestfs_blockdev_getro, 1);
4196   rb_define_method (c_guestfs, "blockdev_getss",
4197         ruby_guestfs_blockdev_getss, 1);
4198   rb_define_method (c_guestfs, "blockdev_getbsz",
4199         ruby_guestfs_blockdev_getbsz, 1);
4200   rb_define_method (c_guestfs, "blockdev_setbsz",
4201         ruby_guestfs_blockdev_setbsz, 2);
4202   rb_define_method (c_guestfs, "blockdev_getsz",
4203         ruby_guestfs_blockdev_getsz, 1);
4204   rb_define_method (c_guestfs, "blockdev_getsize64",
4205         ruby_guestfs_blockdev_getsize64, 1);
4206   rb_define_method (c_guestfs, "blockdev_flushbufs",
4207         ruby_guestfs_blockdev_flushbufs, 1);
4208   rb_define_method (c_guestfs, "blockdev_rereadpt",
4209         ruby_guestfs_blockdev_rereadpt, 1);
4210   rb_define_method (c_guestfs, "upload",
4211         ruby_guestfs_upload, 2);
4212   rb_define_method (c_guestfs, "download",
4213         ruby_guestfs_download, 2);
4214   rb_define_method (c_guestfs, "checksum",
4215         ruby_guestfs_checksum, 2);
4216   rb_define_method (c_guestfs, "tar_in",
4217         ruby_guestfs_tar_in, 2);
4218   rb_define_method (c_guestfs, "tar_out",
4219         ruby_guestfs_tar_out, 2);
4220   rb_define_method (c_guestfs, "tgz_in",
4221         ruby_guestfs_tgz_in, 2);
4222   rb_define_method (c_guestfs, "tgz_out",
4223         ruby_guestfs_tgz_out, 2);
4224   rb_define_method (c_guestfs, "mount_ro",
4225         ruby_guestfs_mount_ro, 2);
4226   rb_define_method (c_guestfs, "mount_options",
4227         ruby_guestfs_mount_options, 3);
4228   rb_define_method (c_guestfs, "mount_vfs",
4229         ruby_guestfs_mount_vfs, 4);
4230   rb_define_method (c_guestfs, "debug",
4231         ruby_guestfs_debug, 2);
4232   rb_define_method (c_guestfs, "lvremove",
4233         ruby_guestfs_lvremove, 1);
4234   rb_define_method (c_guestfs, "vgremove",
4235         ruby_guestfs_vgremove, 1);
4236   rb_define_method (c_guestfs, "pvremove",
4237         ruby_guestfs_pvremove, 1);
4238   rb_define_method (c_guestfs, "set_e2label",
4239         ruby_guestfs_set_e2label, 2);
4240   rb_define_method (c_guestfs, "get_e2label",
4241         ruby_guestfs_get_e2label, 1);
4242   rb_define_method (c_guestfs, "set_e2uuid",
4243         ruby_guestfs_set_e2uuid, 2);
4244   rb_define_method (c_guestfs, "get_e2uuid",
4245         ruby_guestfs_get_e2uuid, 1);
4246   rb_define_method (c_guestfs, "fsck",
4247         ruby_guestfs_fsck, 2);
4248   rb_define_method (c_guestfs, "zero",
4249         ruby_guestfs_zero, 1);
4250   rb_define_method (c_guestfs, "grub_install",
4251         ruby_guestfs_grub_install, 2);
4252   rb_define_method (c_guestfs, "cp",
4253         ruby_guestfs_cp, 2);
4254   rb_define_method (c_guestfs, "cp_a",
4255         ruby_guestfs_cp_a, 2);
4256   rb_define_method (c_guestfs, "mv",
4257         ruby_guestfs_mv, 2);
4258   rb_define_method (c_guestfs, "drop_caches",
4259         ruby_guestfs_drop_caches, 1);
4260   rb_define_method (c_guestfs, "dmesg",
4261         ruby_guestfs_dmesg, 0);
4262   rb_define_method (c_guestfs, "ping_daemon",
4263         ruby_guestfs_ping_daemon, 0);
4264   rb_define_method (c_guestfs, "equal",
4265         ruby_guestfs_equal, 2);
4266   rb_define_method (c_guestfs, "strings",
4267         ruby_guestfs_strings, 1);
4268   rb_define_method (c_guestfs, "strings_e",
4269         ruby_guestfs_strings_e, 2);
4270   rb_define_method (c_guestfs, "hexdump",
4271         ruby_guestfs_hexdump, 1);
4272   rb_define_method (c_guestfs, "zerofree",
4273         ruby_guestfs_zerofree, 1);
4274   rb_define_method (c_guestfs, "pvresize",
4275         ruby_guestfs_pvresize, 1);
4276   rb_define_method (c_guestfs, "sfdisk_N",
4277         ruby_guestfs_sfdisk_N, 6);
4278   rb_define_method (c_guestfs, "sfdisk_l",
4279         ruby_guestfs_sfdisk_l, 1);
4280   rb_define_method (c_guestfs, "sfdisk_kernel_geometry",
4281         ruby_guestfs_sfdisk_kernel_geometry, 1);
4282   rb_define_method (c_guestfs, "sfdisk_disk_geometry",
4283         ruby_guestfs_sfdisk_disk_geometry, 1);
4284   rb_define_method (c_guestfs, "vg_activate_all",
4285         ruby_guestfs_vg_activate_all, 1);
4286   rb_define_method (c_guestfs, "vg_activate",
4287         ruby_guestfs_vg_activate, 2);
4288   rb_define_method (c_guestfs, "lvresize",
4289         ruby_guestfs_lvresize, 2);
4290   rb_define_method (c_guestfs, "resize2fs",
4291         ruby_guestfs_resize2fs, 1);
4292   rb_define_method (c_guestfs, "find",
4293         ruby_guestfs_find, 1);
4294   rb_define_method (c_guestfs, "e2fsck_f",
4295         ruby_guestfs_e2fsck_f, 1);
4296 }