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 static VALUE m_guestfs;                 /* guestfs module */
  32 static VALUE c_guestfs;                 /* guestfs_h handle */
  33 static VALUE e_Error;                   /* used for all errors */
  34
  35 static void ruby_guestfs_free (void *p)
  36 {
  37   if (!p) return;
  38   guestfs_close ((guestfs_h *) p);
  39 }
  40
  41 static VALUE ruby_guestfs_create (VALUE m)
  42 {
  43   guestfs_h *g;
  44
  45   g = guestfs_create ();
  46   if (!g)
  47     rb_raise (e_Error, "failed to create guestfs handle");
  48
  49   /* Don't print error messages to stderr by default. */
  50   guestfs_set_error_handler (g, NULL, NULL);
  51
  52   /* Wrap it, and make sure the close function is called when the
  53    * handle goes away.
  54    */
  55   return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
  56 }
  57
  58 static VALUE ruby_guestfs_close (VALUE gv)
  59 {
  60   guestfs_h *g;
  61   Data_Get_Struct (gv, guestfs_h, g);
  62
  63   ruby_guestfs_free (g);
  64   DATA_PTR (gv) = NULL;
  65
  66   return Qnil;
  67 }
  68
  69 static VALUE ruby_guestfs_launch (VALUE gv)
  70 {
  71   guestfs_h *g;
  72   Data_Get_Struct (gv, guestfs_h, g);
  73   if (!g)
  74     rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
  75
  76
  77   int r;
  78
  79   r = guestfs_launch (g);
  80   if (r == -1)
  81     rb_raise (e_Error, "%s", guestfs_last_error (g));
  82
  83   return Qnil;
  84 }
  85
  86 static VALUE ruby_guestfs_wait_ready (VALUE gv)
  87 {
  88   guestfs_h *g;
  89   Data_Get_Struct (gv, guestfs_h, g);
  90   if (!g)
  91     rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
  92
  93
  94   int r;
  95
  96   r = guestfs_wait_ready (g);
  97   if (r == -1)
  98     rb_raise (e_Error, "%s", guestfs_last_error (g));
  99
 100   return Qnil;
 101 }
 102
 103 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
 104 {
 105   guestfs_h *g;
 106   Data_Get_Struct (gv, guestfs_h, g);
 107   if (!g)
 108     rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
 109
 110
 111   int r;
 112
 113   r = guestfs_kill_subprocess (g);
 114   if (r == -1)
 115     rb_raise (e_Error, "%s", guestfs_last_error (g));
 116
 117   return Qnil;
 118 }
 119
 120 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
 121 {
 122   guestfs_h *g;
 123   Data_Get_Struct (gv, guestfs_h, g);
 124   if (!g)
 125     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
 126
 127   const char *filename = StringValueCStr (filenamev);
 128   if (!filename)
 129     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 130               "filename", "add_drive");
 131
 132   int r;
 133
 134   r = guestfs_add_drive (g, filename);
 135   if (r == -1)
 136     rb_raise (e_Error, "%s", guestfs_last_error (g));
 137
 138   return Qnil;
 139 }
 140
 141 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
 142 {
 143   guestfs_h *g;
 144   Data_Get_Struct (gv, guestfs_h, g);
 145   if (!g)
 146     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
 147
 148   const char *filename = StringValueCStr (filenamev);
 149   if (!filename)
 150     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 151               "filename", "add_cdrom");
 152
 153   int r;
 154
 155   r = guestfs_add_cdrom (g, filename);
 156   if (r == -1)
 157     rb_raise (e_Error, "%s", guestfs_last_error (g));
 158
 159   return Qnil;
 160 }
 161
 162 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
 163 {
 164   guestfs_h *g;
 165   Data_Get_Struct (gv, guestfs_h, g);
 166   if (!g)
 167     rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
 168
 169   const char *qemuparam = StringValueCStr (qemuparamv);
 170   if (!qemuparam)
 171     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 172               "qemuparam", "config");
 173   const char *qemuvalue = StringValueCStr (qemuvaluev);
 174
 175   int r;
 176
 177   r = guestfs_config (g, qemuparam, qemuvalue);
 178   if (r == -1)
 179     rb_raise (e_Error, "%s", guestfs_last_error (g));
 180
 181   return Qnil;
 182 }
 183
 184 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
 185 {
 186   guestfs_h *g;
 187   Data_Get_Struct (gv, guestfs_h, g);
 188   if (!g)
 189     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
 190
 191   const char *path = StringValueCStr (pathv);
 192   if (!path)
 193     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 194               "path", "set_path");
 195
 196   int r;
 197
 198   r = guestfs_set_path (g, path);
 199   if (r == -1)
 200     rb_raise (e_Error, "%s", guestfs_last_error (g));
 201
 202   return Qnil;
 203 }
 204
 205 static VALUE ruby_guestfs_get_path (VALUE gv)
 206 {
 207   guestfs_h *g;
 208   Data_Get_Struct (gv, guestfs_h, g);
 209   if (!g)
 210     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
 211
 212
 213   const char *r;
 214
 215   r = guestfs_get_path (g);
 216   if (r == NULL)
 217     rb_raise (e_Error, "%s", guestfs_last_error (g));
 218
 219   return rb_str_new2 (r);
 220 }
 221
 222 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
 223 {
 224   guestfs_h *g;
 225   Data_Get_Struct (gv, guestfs_h, g);
 226   if (!g)
 227     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
 228
 229   int autosync = NUM2INT (autosyncv);
 230
 231   int r;
 232
 233   r = guestfs_set_autosync (g, autosync);
 234   if (r == -1)
 235     rb_raise (e_Error, "%s", guestfs_last_error (g));
 236
 237   return Qnil;
 238 }
 239
 240 static VALUE ruby_guestfs_get_autosync (VALUE gv)
 241 {
 242   guestfs_h *g;
 243   Data_Get_Struct (gv, guestfs_h, g);
 244   if (!g)
 245     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
 246
 247
 248   int r;
 249
 250   r = guestfs_get_autosync (g);
 251   if (r == -1)
 252     rb_raise (e_Error, "%s", guestfs_last_error (g));
 253
 254   return INT2NUM (r);
 255 }
 256
 257 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
 258 {
 259   guestfs_h *g;
 260   Data_Get_Struct (gv, guestfs_h, g);
 261   if (!g)
 262     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
 263
 264   int verbose = NUM2INT (verbosev);
 265
 266   int r;
 267
 268   r = guestfs_set_verbose (g, verbose);
 269   if (r == -1)
 270     rb_raise (e_Error, "%s", guestfs_last_error (g));
 271
 272   return Qnil;
 273 }
 274
 275 static VALUE ruby_guestfs_get_verbose (VALUE gv)
 276 {
 277   guestfs_h *g;
 278   Data_Get_Struct (gv, guestfs_h, g);
 279   if (!g)
 280     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
 281
 282
 283   int r;
 284
 285   r = guestfs_get_verbose (g);
 286   if (r == -1)
 287     rb_raise (e_Error, "%s", guestfs_last_error (g));
 288
 289   return INT2NUM (r);
 290 }
 291
 292 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
 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", "mount");
 298
 299   const char *device = StringValueCStr (devicev);
 300   if (!device)
 301     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 302               "device", "mount");
 303   const char *mountpoint = StringValueCStr (mountpointv);
 304   if (!mountpoint)
 305     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 306               "mountpoint", "mount");
 307
 308   int r;
 309
 310   r = guestfs_mount (g, device, mountpoint);
 311   if (r == -1)
 312     rb_raise (e_Error, "%s", guestfs_last_error (g));
 313
 314   return Qnil;
 315 }
 316
 317 static VALUE ruby_guestfs_sync (VALUE gv)
 318 {
 319   guestfs_h *g;
 320   Data_Get_Struct (gv, guestfs_h, g);
 321   if (!g)
 322     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
 323
 324
 325   int r;
 326
 327   r = guestfs_sync (g);
 328   if (r == -1)
 329     rb_raise (e_Error, "%s", guestfs_last_error (g));
 330
 331   return Qnil;
 332 }
 333
 334 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
 335 {
 336   guestfs_h *g;
 337   Data_Get_Struct (gv, guestfs_h, g);
 338   if (!g)
 339     rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
 340
 341   const char *path = StringValueCStr (pathv);
 342   if (!path)
 343     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 344               "path", "touch");
 345
 346   int r;
 347
 348   r = guestfs_touch (g, path);
 349   if (r == -1)
 350     rb_raise (e_Error, "%s", guestfs_last_error (g));
 351
 352   return Qnil;
 353 }
 354
 355 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
 356 {
 357   guestfs_h *g;
 358   Data_Get_Struct (gv, guestfs_h, g);
 359   if (!g)
 360     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
 361
 362   const char *path = StringValueCStr (pathv);
 363   if (!path)
 364     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 365               "path", "cat");
 366
 367   char *r;
 368
 369   r = guestfs_cat (g, path);
 370   if (r == NULL)
 371     rb_raise (e_Error, "%s", guestfs_last_error (g));
 372
 373   VALUE rv = rb_str_new2 (r);
 374   free (r);
 375   return rv;
 376 }
 377
 378 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
 379 {
 380   guestfs_h *g;
 381   Data_Get_Struct (gv, guestfs_h, g);
 382   if (!g)
 383     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
 384
 385   const char *directory = StringValueCStr (directoryv);
 386   if (!directory)
 387     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 388               "directory", "ll");
 389
 390   char *r;
 391
 392   r = guestfs_ll (g, directory);
 393   if (r == NULL)
 394     rb_raise (e_Error, "%s", guestfs_last_error (g));
 395
 396   VALUE rv = rb_str_new2 (r);
 397   free (r);
 398   return rv;
 399 }
 400
 401 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
 402 {
 403   guestfs_h *g;
 404   Data_Get_Struct (gv, guestfs_h, g);
 405   if (!g)
 406     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
 407
 408   const char *directory = StringValueCStr (directoryv);
 409   if (!directory)
 410     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 411               "directory", "ls");
 412
 413   char **r;
 414
 415   r = guestfs_ls (g, directory);
 416   if (r == NULL)
 417     rb_raise (e_Error, "%s", guestfs_last_error (g));
 418
 419   int i, len = 0;
 420   for (i = 0; r[i] != NULL; ++i) len++;
 421   VALUE rv = rb_ary_new2 (len);
 422   for (i = 0; r[i] != NULL; ++i) {
 423     rb_ary_push (rv, rb_str_new2 (r[i]));
 424     free (r[i]);
 425   }
 426   free (r);
 427   return rv;
 428 }
 429
 430 static VALUE ruby_guestfs_list_devices (VALUE gv)
 431 {
 432   guestfs_h *g;
 433   Data_Get_Struct (gv, guestfs_h, g);
 434   if (!g)
 435     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
 436
 437
 438   char **r;
 439
 440   r = guestfs_list_devices (g);
 441   if (r == NULL)
 442     rb_raise (e_Error, "%s", guestfs_last_error (g));
 443
 444   int i, len = 0;
 445   for (i = 0; r[i] != NULL; ++i) len++;
 446   VALUE rv = rb_ary_new2 (len);
 447   for (i = 0; r[i] != NULL; ++i) {
 448     rb_ary_push (rv, rb_str_new2 (r[i]));
 449     free (r[i]);
 450   }
 451   free (r);
 452   return rv;
 453 }
 454
 455 static VALUE ruby_guestfs_list_partitions (VALUE gv)
 456 {
 457   guestfs_h *g;
 458   Data_Get_Struct (gv, guestfs_h, g);
 459   if (!g)
 460     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
 461
 462
 463   char **r;
 464
 465   r = guestfs_list_partitions (g);
 466   if (r == NULL)
 467     rb_raise (e_Error, "%s", guestfs_last_error (g));
 468
 469   int i, len = 0;
 470   for (i = 0; r[i] != NULL; ++i) len++;
 471   VALUE rv = rb_ary_new2 (len);
 472   for (i = 0; r[i] != NULL; ++i) {
 473     rb_ary_push (rv, rb_str_new2 (r[i]));
 474     free (r[i]);
 475   }
 476   free (r);
 477   return rv;
 478 }
 479
 480 static VALUE ruby_guestfs_pvs (VALUE gv)
 481 {
 482   guestfs_h *g;
 483   Data_Get_Struct (gv, guestfs_h, g);
 484   if (!g)
 485     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
 486
 487
 488   char **r;
 489
 490   r = guestfs_pvs (g);
 491   if (r == NULL)
 492     rb_raise (e_Error, "%s", guestfs_last_error (g));
 493
 494   int i, len = 0;
 495   for (i = 0; r[i] != NULL; ++i) len++;
 496   VALUE rv = rb_ary_new2 (len);
 497   for (i = 0; r[i] != NULL; ++i) {
 498     rb_ary_push (rv, rb_str_new2 (r[i]));
 499     free (r[i]);
 500   }
 501   free (r);
 502   return rv;
 503 }
 504
 505 static VALUE ruby_guestfs_vgs (VALUE gv)
 506 {
 507   guestfs_h *g;
 508   Data_Get_Struct (gv, guestfs_h, g);
 509   if (!g)
 510     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
 511
 512
 513   char **r;
 514
 515   r = guestfs_vgs (g);
 516   if (r == NULL)
 517     rb_raise (e_Error, "%s", guestfs_last_error (g));
 518
 519   int i, len = 0;
 520   for (i = 0; r[i] != NULL; ++i) len++;
 521   VALUE rv = rb_ary_new2 (len);
 522   for (i = 0; r[i] != NULL; ++i) {
 523     rb_ary_push (rv, rb_str_new2 (r[i]));
 524     free (r[i]);
 525   }
 526   free (r);
 527   return rv;
 528 }
 529
 530 static VALUE ruby_guestfs_lvs (VALUE gv)
 531 {
 532   guestfs_h *g;
 533   Data_Get_Struct (gv, guestfs_h, g);
 534   if (!g)
 535     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
 536
 537
 538   char **r;
 539
 540   r = guestfs_lvs (g);
 541   if (r == NULL)
 542     rb_raise (e_Error, "%s", guestfs_last_error (g));
 543
 544   int i, len = 0;
 545   for (i = 0; r[i] != NULL; ++i) len++;
 546   VALUE rv = rb_ary_new2 (len);
 547   for (i = 0; r[i] != NULL; ++i) {
 548     rb_ary_push (rv, rb_str_new2 (r[i]));
 549     free (r[i]);
 550   }
 551   free (r);
 552   return rv;
 553 }
 554
 555 static VALUE ruby_guestfs_pvs_full (VALUE gv)
 556 {
 557   guestfs_h *g;
 558   Data_Get_Struct (gv, guestfs_h, g);
 559   if (!g)
 560     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
 561
 562
 563   struct guestfs_lvm_pv_list *r;
 564
 565   r = guestfs_pvs_full (g);
 566   if (r == NULL)
 567     rb_raise (e_Error, "%s", guestfs_last_error (g));
 568
 569   VALUE rv = rb_ary_new2 (r->len);
 570   int i;
 571   for (i = 0; i < r->len; ++i) {
 572     VALUE hv = rb_hash_new ();
 573     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
 574     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
 575     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
 576     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
 577     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
 578     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
 579     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
 580     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
 581     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
 582     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
 583     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
 584     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
 585     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
 586     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
 587     rb_ary_push (rv, hv);
 588   }
 589   guestfs_free_lvm_pv_list (r);
 590   return rv;
 591 }
 592
 593 static VALUE ruby_guestfs_vgs_full (VALUE gv)
 594 {
 595   guestfs_h *g;
 596   Data_Get_Struct (gv, guestfs_h, g);
 597   if (!g)
 598     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
 599
 600
 601   struct guestfs_lvm_vg_list *r;
 602
 603   r = guestfs_vgs_full (g);
 604   if (r == NULL)
 605     rb_raise (e_Error, "%s", guestfs_last_error (g));
 606
 607   VALUE rv = rb_ary_new2 (r->len);
 608   int i;
 609   for (i = 0; i < r->len; ++i) {
 610     VALUE hv = rb_hash_new ();
 611     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
 612     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
 613     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
 614     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
 615     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
 616     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
 617     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
 618     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
 619     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
 620     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
 621     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
 622     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
 623     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
 624     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
 625     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
 626     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
 627     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
 628     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
 629     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
 630     rb_ary_push (rv, hv);
 631   }
 632   guestfs_free_lvm_vg_list (r);
 633   return rv;
 634 }
 635
 636 static VALUE ruby_guestfs_lvs_full (VALUE gv)
 637 {
 638   guestfs_h *g;
 639   Data_Get_Struct (gv, guestfs_h, g);
 640   if (!g)
 641     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
 642
 643
 644   struct guestfs_lvm_lv_list *r;
 645
 646   r = guestfs_lvs_full (g);
 647   if (r == NULL)
 648     rb_raise (e_Error, "%s", guestfs_last_error (g));
 649
 650   VALUE rv = rb_ary_new2 (r->len);
 651   int i;
 652   for (i = 0; i < r->len; ++i) {
 653     VALUE hv = rb_hash_new ();
 654     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
 655     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
 656     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
 657     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
 658     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
 659     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
 660     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
 661     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
 662     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
 663     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
 664     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
 665     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
 666     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
 667     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
 668     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
 669     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
 670     rb_ary_push (rv, hv);
 671   }
 672   guestfs_free_lvm_lv_list (r);
 673   return rv;
 674 }
 675
 676 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
 677 {
 678   guestfs_h *g;
 679   Data_Get_Struct (gv, guestfs_h, g);
 680   if (!g)
 681     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
 682
 683   const char *path = StringValueCStr (pathv);
 684   if (!path)
 685     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 686               "path", "read_lines");
 687
 688   char **r;
 689
 690   r = guestfs_read_lines (g, path);
 691   if (r == NULL)
 692     rb_raise (e_Error, "%s", guestfs_last_error (g));
 693
 694   int i, len = 0;
 695   for (i = 0; r[i] != NULL; ++i) len++;
 696   VALUE rv = rb_ary_new2 (len);
 697   for (i = 0; r[i] != NULL; ++i) {
 698     rb_ary_push (rv, rb_str_new2 (r[i]));
 699     free (r[i]);
 700   }
 701   free (r);
 702   return rv;
 703 }
 704
 705 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
 706 {
 707   guestfs_h *g;
 708   Data_Get_Struct (gv, guestfs_h, g);
 709   if (!g)
 710     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
 711
 712   const char *root = StringValueCStr (rootv);
 713   if (!root)
 714     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 715               "root", "aug_init");
 716   int flags = NUM2INT (flagsv);
 717
 718   int r;
 719
 720   r = guestfs_aug_init (g, root, flags);
 721   if (r == -1)
 722     rb_raise (e_Error, "%s", guestfs_last_error (g));
 723
 724   return Qnil;
 725 }
 726
 727 static VALUE ruby_guestfs_aug_close (VALUE gv)
 728 {
 729   guestfs_h *g;
 730   Data_Get_Struct (gv, guestfs_h, g);
 731   if (!g)
 732     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
 733
 734
 735   int r;
 736
 737   r = guestfs_aug_close (g);
 738   if (r == -1)
 739     rb_raise (e_Error, "%s", guestfs_last_error (g));
 740
 741   return Qnil;
 742 }
 743
 744 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
 745 {
 746   guestfs_h *g;
 747   Data_Get_Struct (gv, guestfs_h, g);
 748   if (!g)
 749     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
 750
 751   const char *name = StringValueCStr (namev);
 752   if (!name)
 753     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 754               "name", "aug_defvar");
 755   const char *expr = StringValueCStr (exprv);
 756
 757   int r;
 758
 759   r = guestfs_aug_defvar (g, name, expr);
 760   if (r == -1)
 761     rb_raise (e_Error, "%s", guestfs_last_error (g));
 762
 763   return INT2NUM (r);
 764 }
 765
 766 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
 767 {
 768   guestfs_h *g;
 769   Data_Get_Struct (gv, guestfs_h, g);
 770   if (!g)
 771     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
 772
 773   const char *name = StringValueCStr (namev);
 774   if (!name)
 775     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 776               "name", "aug_defnode");
 777   const char *expr = StringValueCStr (exprv);
 778   if (!expr)
 779     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 780               "expr", "aug_defnode");
 781   const char *val = StringValueCStr (valv);
 782   if (!val)
 783     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 784               "val", "aug_defnode");
 785
 786   struct guestfs_int_bool *r;
 787
 788   r = guestfs_aug_defnode (g, name, expr, val);
 789   if (r == NULL)
 790     rb_raise (e_Error, "%s", guestfs_last_error (g));
 791
 792   VALUE rv = rb_ary_new2 (2);
 793   rb_ary_push (rv, INT2NUM (r->i));
 794   rb_ary_push (rv, INT2NUM (r->b));
 795   guestfs_free_int_bool (r);
 796   return rv;
 797 }
 798
 799 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
 800 {
 801   guestfs_h *g;
 802   Data_Get_Struct (gv, guestfs_h, g);
 803   if (!g)
 804     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
 805
 806   const char *path = StringValueCStr (pathv);
 807   if (!path)
 808     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 809               "path", "aug_get");
 810
 811   char *r;
 812
 813   r = guestfs_aug_get (g, path);
 814   if (r == NULL)
 815     rb_raise (e_Error, "%s", guestfs_last_error (g));
 816
 817   VALUE rv = rb_str_new2 (r);
 818   free (r);
 819   return rv;
 820 }
 821
 822 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
 823 {
 824   guestfs_h *g;
 825   Data_Get_Struct (gv, guestfs_h, g);
 826   if (!g)
 827     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
 828
 829   const char *path = StringValueCStr (pathv);
 830   if (!path)
 831     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 832               "path", "aug_set");
 833   const char *val = StringValueCStr (valv);
 834   if (!val)
 835     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 836               "val", "aug_set");
 837
 838   int r;
 839
 840   r = guestfs_aug_set (g, path, val);
 841   if (r == -1)
 842     rb_raise (e_Error, "%s", guestfs_last_error (g));
 843
 844   return Qnil;
 845 }
 846
 847 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
 848 {
 849   guestfs_h *g;
 850   Data_Get_Struct (gv, guestfs_h, g);
 851   if (!g)
 852     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
 853
 854   const char *path = StringValueCStr (pathv);
 855   if (!path)
 856     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 857               "path", "aug_insert");
 858   const char *label = StringValueCStr (labelv);
 859   if (!label)
 860     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 861               "label", "aug_insert");
 862   int before = NUM2INT (beforev);
 863
 864   int r;
 865
 866   r = guestfs_aug_insert (g, path, label, before);
 867   if (r == -1)
 868     rb_raise (e_Error, "%s", guestfs_last_error (g));
 869
 870   return Qnil;
 871 }
 872
 873 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
 874 {
 875   guestfs_h *g;
 876   Data_Get_Struct (gv, guestfs_h, g);
 877   if (!g)
 878     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
 879
 880   const char *path = StringValueCStr (pathv);
 881   if (!path)
 882     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 883               "path", "aug_rm");
 884
 885   int r;
 886
 887   r = guestfs_aug_rm (g, path);
 888   if (r == -1)
 889     rb_raise (e_Error, "%s", guestfs_last_error (g));
 890
 891   return INT2NUM (r);
 892 }
 893
 894 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
 895 {
 896   guestfs_h *g;
 897   Data_Get_Struct (gv, guestfs_h, g);
 898   if (!g)
 899     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
 900
 901   const char *src = StringValueCStr (srcv);
 902   if (!src)
 903     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 904               "src", "aug_mv");
 905   const char *dest = StringValueCStr (destv);
 906   if (!dest)
 907     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 908               "dest", "aug_mv");
 909
 910   int r;
 911
 912   r = guestfs_aug_mv (g, src, dest);
 913   if (r == -1)
 914     rb_raise (e_Error, "%s", guestfs_last_error (g));
 915
 916   return Qnil;
 917 }
 918
 919 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
 920 {
 921   guestfs_h *g;
 922   Data_Get_Struct (gv, guestfs_h, g);
 923   if (!g)
 924     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
 925
 926   const char *path = StringValueCStr (pathv);
 927   if (!path)
 928     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 929               "path", "aug_match");
 930
 931   char **r;
 932
 933   r = guestfs_aug_match (g, path);
 934   if (r == NULL)
 935     rb_raise (e_Error, "%s", guestfs_last_error (g));
 936
 937   int i, len = 0;
 938   for (i = 0; r[i] != NULL; ++i) len++;
 939   VALUE rv = rb_ary_new2 (len);
 940   for (i = 0; r[i] != NULL; ++i) {
 941     rb_ary_push (rv, rb_str_new2 (r[i]));
 942     free (r[i]);
 943   }
 944   free (r);
 945   return rv;
 946 }
 947
 948 static VALUE ruby_guestfs_aug_save (VALUE gv)
 949 {
 950   guestfs_h *g;
 951   Data_Get_Struct (gv, guestfs_h, g);
 952   if (!g)
 953     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
 954
 955
 956   int r;
 957
 958   r = guestfs_aug_save (g);
 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_aug_load (VALUE gv)
 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", "aug_load");
 971
 972
 973   int r;
 974
 975   r = guestfs_aug_load (g);
 976   if (r == -1)
 977     rb_raise (e_Error, "%s", guestfs_last_error (g));
 978
 979   return Qnil;
 980 }
 981
 982 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
 983 {
 984   guestfs_h *g;
 985   Data_Get_Struct (gv, guestfs_h, g);
 986   if (!g)
 987     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
 988
 989   const char *path = StringValueCStr (pathv);
 990   if (!path)
 991     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 992               "path", "aug_ls");
 993
 994   char **r;
 995
 996   r = guestfs_aug_ls (g, path);
 997   if (r == NULL)
 998     rb_raise (e_Error, "%s", guestfs_last_error (g));
 999
1000   int i, len = 0;
1001   for (i = 0; r[i] != NULL; ++i) len++;
1002   VALUE rv = rb_ary_new2 (len);
1003   for (i = 0; r[i] != NULL; ++i) {
1004     rb_ary_push (rv, rb_str_new2 (r[i]));
1005     free (r[i]);
1006   }
1007   free (r);
1008   return rv;
1009 }
1010
1011 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
1012 {
1013   guestfs_h *g;
1014   Data_Get_Struct (gv, guestfs_h, g);
1015   if (!g)
1016     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
1017
1018   const char *path = StringValueCStr (pathv);
1019   if (!path)
1020     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1021               "path", "rm");
1022
1023   int r;
1024
1025   r = guestfs_rm (g, path);
1026   if (r == -1)
1027     rb_raise (e_Error, "%s", guestfs_last_error (g));
1028
1029   return Qnil;
1030 }
1031
1032 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
1033 {
1034   guestfs_h *g;
1035   Data_Get_Struct (gv, guestfs_h, g);
1036   if (!g)
1037     rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
1038
1039   const char *path = StringValueCStr (pathv);
1040   if (!path)
1041     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1042               "path", "rmdir");
1043
1044   int r;
1045
1046   r = guestfs_rmdir (g, path);
1047   if (r == -1)
1048     rb_raise (e_Error, "%s", guestfs_last_error (g));
1049
1050   return Qnil;
1051 }
1052
1053 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
1054 {
1055   guestfs_h *g;
1056   Data_Get_Struct (gv, guestfs_h, g);
1057   if (!g)
1058     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
1059
1060   const char *path = StringValueCStr (pathv);
1061   if (!path)
1062     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1063               "path", "rm_rf");
1064
1065   int r;
1066
1067   r = guestfs_rm_rf (g, path);
1068   if (r == -1)
1069     rb_raise (e_Error, "%s", guestfs_last_error (g));
1070
1071   return Qnil;
1072 }
1073
1074 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
1075 {
1076   guestfs_h *g;
1077   Data_Get_Struct (gv, guestfs_h, g);
1078   if (!g)
1079     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
1080
1081   const char *path = StringValueCStr (pathv);
1082   if (!path)
1083     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1084               "path", "mkdir");
1085
1086   int r;
1087
1088   r = guestfs_mkdir (g, path);
1089   if (r == -1)
1090     rb_raise (e_Error, "%s", guestfs_last_error (g));
1091
1092   return Qnil;
1093 }
1094
1095 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
1096 {
1097   guestfs_h *g;
1098   Data_Get_Struct (gv, guestfs_h, g);
1099   if (!g)
1100     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
1101
1102   const char *path = StringValueCStr (pathv);
1103   if (!path)
1104     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1105               "path", "mkdir_p");
1106
1107   int r;
1108
1109   r = guestfs_mkdir_p (g, path);
1110   if (r == -1)
1111     rb_raise (e_Error, "%s", guestfs_last_error (g));
1112
1113   return Qnil;
1114 }
1115
1116 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
1117 {
1118   guestfs_h *g;
1119   Data_Get_Struct (gv, guestfs_h, g);
1120   if (!g)
1121     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
1122
1123   int mode = NUM2INT (modev);
1124   const char *path = StringValueCStr (pathv);
1125   if (!path)
1126     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1127               "path", "chmod");
1128
1129   int r;
1130
1131   r = guestfs_chmod (g, mode, path);
1132   if (r == -1)
1133     rb_raise (e_Error, "%s", guestfs_last_error (g));
1134
1135   return Qnil;
1136 }
1137
1138 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
1139 {
1140   guestfs_h *g;
1141   Data_Get_Struct (gv, guestfs_h, g);
1142   if (!g)
1143     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
1144
1145   int owner = NUM2INT (ownerv);
1146   int group = NUM2INT (groupv);
1147   const char *path = StringValueCStr (pathv);
1148   if (!path)
1149     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1150               "path", "chown");
1151
1152   int r;
1153
1154   r = guestfs_chown (g, owner, group, path);
1155   if (r == -1)
1156     rb_raise (e_Error, "%s", guestfs_last_error (g));
1157
1158   return Qnil;
1159 }
1160
1161 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
1162 {
1163   guestfs_h *g;
1164   Data_Get_Struct (gv, guestfs_h, g);
1165   if (!g)
1166     rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
1167
1168   const char *path = StringValueCStr (pathv);
1169   if (!path)
1170     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1171               "path", "exists");
1172
1173   int r;
1174
1175   r = guestfs_exists (g, path);
1176   if (r == -1)
1177     rb_raise (e_Error, "%s", guestfs_last_error (g));
1178
1179   return INT2NUM (r);
1180 }
1181
1182 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
1183 {
1184   guestfs_h *g;
1185   Data_Get_Struct (gv, guestfs_h, g);
1186   if (!g)
1187     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
1188
1189   const char *path = StringValueCStr (pathv);
1190   if (!path)
1191     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1192               "path", "is_file");
1193
1194   int r;
1195
1196   r = guestfs_is_file (g, path);
1197   if (r == -1)
1198     rb_raise (e_Error, "%s", guestfs_last_error (g));
1199
1200   return INT2NUM (r);
1201 }
1202
1203 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
1204 {
1205   guestfs_h *g;
1206   Data_Get_Struct (gv, guestfs_h, g);
1207   if (!g)
1208     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
1209
1210   const char *path = StringValueCStr (pathv);
1211   if (!path)
1212     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1213               "path", "is_dir");
1214
1215   int r;
1216
1217   r = guestfs_is_dir (g, path);
1218   if (r == -1)
1219     rb_raise (e_Error, "%s", guestfs_last_error (g));
1220
1221   return INT2NUM (r);
1222 }
1223
1224 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
1225 {
1226   guestfs_h *g;
1227   Data_Get_Struct (gv, guestfs_h, g);
1228   if (!g)
1229     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
1230
1231   const char *device = StringValueCStr (devicev);
1232   if (!device)
1233     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1234               "device", "pvcreate");
1235
1236   int r;
1237
1238   r = guestfs_pvcreate (g, device);
1239   if (r == -1)
1240     rb_raise (e_Error, "%s", guestfs_last_error (g));
1241
1242   return Qnil;
1243 }
1244
1245 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
1246 {
1247   guestfs_h *g;
1248   Data_Get_Struct (gv, guestfs_h, g);
1249   if (!g)
1250     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
1251
1252   const char *volgroup = StringValueCStr (volgroupv);
1253   if (!volgroup)
1254     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1255               "volgroup", "vgcreate");
1256   char **physvols;  {
1257     int i, len;
1258     len = RARRAY_LEN (physvolsv);
1259     physvols = malloc (sizeof (char *) * (len+1));
1260     for (i = 0; i < len; ++i) {
1261       VALUE v = rb_ary_entry (physvolsv, i);
1262       physvols[i] = StringValueCStr (v);
1263     }
1264   }
1265
1266   int r;
1267
1268   r = guestfs_vgcreate (g, volgroup, physvols);
1269   free (physvols);
1270   if (r == -1)
1271     rb_raise (e_Error, "%s", guestfs_last_error (g));
1272
1273   return Qnil;
1274 }
1275
1276 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
1277 {
1278   guestfs_h *g;
1279   Data_Get_Struct (gv, guestfs_h, g);
1280   if (!g)
1281     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
1282
1283   const char *logvol = StringValueCStr (logvolv);
1284   if (!logvol)
1285     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1286               "logvol", "lvcreate");
1287   const char *volgroup = StringValueCStr (volgroupv);
1288   if (!volgroup)
1289     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1290               "volgroup", "lvcreate");
1291   int mbytes = NUM2INT (mbytesv);
1292
1293   int r;
1294
1295   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1296   if (r == -1)
1297     rb_raise (e_Error, "%s", guestfs_last_error (g));
1298
1299   return Qnil;
1300 }
1301
1302 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
1303 {
1304   guestfs_h *g;
1305   Data_Get_Struct (gv, guestfs_h, g);
1306   if (!g)
1307     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
1308
1309   const char *fstype = StringValueCStr (fstypev);
1310   if (!fstype)
1311     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1312               "fstype", "mkfs");
1313   const char *device = StringValueCStr (devicev);
1314   if (!device)
1315     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1316               "device", "mkfs");
1317
1318   int r;
1319
1320   r = guestfs_mkfs (g, fstype, device);
1321   if (r == -1)
1322     rb_raise (e_Error, "%s", guestfs_last_error (g));
1323
1324   return Qnil;
1325 }
1326
1327 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
1328 {
1329   guestfs_h *g;
1330   Data_Get_Struct (gv, guestfs_h, g);
1331   if (!g)
1332     rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
1333
1334   const char *device = StringValueCStr (devicev);
1335   if (!device)
1336     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1337               "device", "sfdisk");
1338   int cyls = NUM2INT (cylsv);
1339   int heads = NUM2INT (headsv);
1340   int sectors = NUM2INT (sectorsv);
1341   char **lines;  {
1342     int i, len;
1343     len = RARRAY_LEN (linesv);
1344     lines = malloc (sizeof (char *) * (len+1));
1345     for (i = 0; i < len; ++i) {
1346       VALUE v = rb_ary_entry (linesv, i);
1347       lines[i] = StringValueCStr (v);
1348     }
1349   }
1350
1351   int r;
1352
1353   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1354   free (lines);
1355   if (r == -1)
1356     rb_raise (e_Error, "%s", guestfs_last_error (g));
1357
1358   return Qnil;
1359 }
1360
1361 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
1362 {
1363   guestfs_h *g;
1364   Data_Get_Struct (gv, guestfs_h, g);
1365   if (!g)
1366     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
1367
1368   const char *path = StringValueCStr (pathv);
1369   if (!path)
1370     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1371               "path", "write_file");
1372   const char *content = StringValueCStr (contentv);
1373   if (!content)
1374     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1375               "content", "write_file");
1376   int size = NUM2INT (sizev);
1377
1378   int r;
1379
1380   r = guestfs_write_file (g, path, content, size);
1381   if (r == -1)
1382     rb_raise (e_Error, "%s", guestfs_last_error (g));
1383
1384   return Qnil;
1385 }
1386
1387 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
1388 {
1389   guestfs_h *g;
1390   Data_Get_Struct (gv, guestfs_h, g);
1391   if (!g)
1392     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
1393
1394   const char *pathordevice = StringValueCStr (pathordevicev);
1395   if (!pathordevice)
1396     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1397               "pathordevice", "umount");
1398
1399   int r;
1400
1401   r = guestfs_umount (g, pathordevice);
1402   if (r == -1)
1403     rb_raise (e_Error, "%s", guestfs_last_error (g));
1404
1405   return Qnil;
1406 }
1407
1408 static VALUE ruby_guestfs_mounts (VALUE gv)
1409 {
1410   guestfs_h *g;
1411   Data_Get_Struct (gv, guestfs_h, g);
1412   if (!g)
1413     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
1414
1415
1416   char **r;
1417
1418   r = guestfs_mounts (g);
1419   if (r == NULL)
1420     rb_raise (e_Error, "%s", guestfs_last_error (g));
1421
1422   int i, len = 0;
1423   for (i = 0; r[i] != NULL; ++i) len++;
1424   VALUE rv = rb_ary_new2 (len);
1425   for (i = 0; r[i] != NULL; ++i) {
1426     rb_ary_push (rv, rb_str_new2 (r[i]));
1427     free (r[i]);
1428   }
1429   free (r);
1430   return rv;
1431 }
1432
1433 static VALUE ruby_guestfs_umount_all (VALUE gv)
1434 {
1435   guestfs_h *g;
1436   Data_Get_Struct (gv, guestfs_h, g);
1437   if (!g)
1438     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
1439
1440
1441   int r;
1442
1443   r = guestfs_umount_all (g);
1444   if (r == -1)
1445     rb_raise (e_Error, "%s", guestfs_last_error (g));
1446
1447   return Qnil;
1448 }
1449
1450 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
1451 {
1452   guestfs_h *g;
1453   Data_Get_Struct (gv, guestfs_h, g);
1454   if (!g)
1455     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
1456
1457
1458   int r;
1459
1460   r = guestfs_lvm_remove_all (g);
1461   if (r == -1)
1462     rb_raise (e_Error, "%s", guestfs_last_error (g));
1463
1464   return Qnil;
1465 }
1466
1467 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
1468 {
1469   guestfs_h *g;
1470   Data_Get_Struct (gv, guestfs_h, g);
1471   if (!g)
1472     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
1473
1474   const char *path = StringValueCStr (pathv);
1475   if (!path)
1476     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1477               "path", "file");
1478
1479   char *r;
1480
1481   r = guestfs_file (g, path);
1482   if (r == NULL)
1483     rb_raise (e_Error, "%s", guestfs_last_error (g));
1484
1485   VALUE rv = rb_str_new2 (r);
1486   free (r);
1487   return rv;
1488 }
1489
1490 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
1491 {
1492   guestfs_h *g;
1493   Data_Get_Struct (gv, guestfs_h, g);
1494   if (!g)
1495     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
1496
1497   char **arguments;  {
1498     int i, len;
1499     len = RARRAY_LEN (argumentsv);
1500     arguments = malloc (sizeof (char *) * (len+1));
1501     for (i = 0; i < len; ++i) {
1502       VALUE v = rb_ary_entry (argumentsv, i);
1503       arguments[i] = StringValueCStr (v);
1504     }
1505   }
1506
1507   char *r;
1508
1509   r = guestfs_command (g, arguments);
1510   free (arguments);
1511   if (r == NULL)
1512     rb_raise (e_Error, "%s", guestfs_last_error (g));
1513
1514   VALUE rv = rb_str_new2 (r);
1515   free (r);
1516   return rv;
1517 }
1518
1519 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
1520 {
1521   guestfs_h *g;
1522   Data_Get_Struct (gv, guestfs_h, g);
1523   if (!g)
1524     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
1525
1526   char **arguments;  {
1527     int i, len;
1528     len = RARRAY_LEN (argumentsv);
1529     arguments = malloc (sizeof (char *) * (len+1));
1530     for (i = 0; i < len; ++i) {
1531       VALUE v = rb_ary_entry (argumentsv, i);
1532       arguments[i] = StringValueCStr (v);
1533     }
1534   }
1535
1536   char **r;
1537
1538   r = guestfs_command_lines (g, arguments);
1539   free (arguments);
1540   if (r == NULL)
1541     rb_raise (e_Error, "%s", guestfs_last_error (g));
1542
1543   int i, len = 0;
1544   for (i = 0; r[i] != NULL; ++i) len++;
1545   VALUE rv = rb_ary_new2 (len);
1546   for (i = 0; r[i] != NULL; ++i) {
1547     rb_ary_push (rv, rb_str_new2 (r[i]));
1548     free (r[i]);
1549   }
1550   free (r);
1551   return rv;
1552 }
1553
1554 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
1555 {
1556   guestfs_h *g;
1557   Data_Get_Struct (gv, guestfs_h, g);
1558   if (!g)
1559     rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
1560
1561   const char *path = StringValueCStr (pathv);
1562   if (!path)
1563     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1564               "path", "stat");
1565
1566   struct guestfs_stat *r;
1567
1568   r = guestfs_stat (g, path);
1569   if (r == NULL)
1570     rb_raise (e_Error, "%s", guestfs_last_error (g));
1571
1572   VALUE rv = rb_hash_new ();
1573   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1574   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1575   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1576   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1577   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1578   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1579   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1580   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1581   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1582   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1583   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1584   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1585   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1586   free (r);
1587   return rv;
1588 }
1589
1590 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
1591 {
1592   guestfs_h *g;
1593   Data_Get_Struct (gv, guestfs_h, g);
1594   if (!g)
1595     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
1596
1597   const char *path = StringValueCStr (pathv);
1598   if (!path)
1599     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1600               "path", "lstat");
1601
1602   struct guestfs_stat *r;
1603
1604   r = guestfs_lstat (g, path);
1605   if (r == NULL)
1606     rb_raise (e_Error, "%s", guestfs_last_error (g));
1607
1608   VALUE rv = rb_hash_new ();
1609   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1610   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1611   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1612   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1613   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1614   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1615   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1616   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1617   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1618   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1619   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1620   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1621   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1622   free (r);
1623   return rv;
1624 }
1625
1626 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
1627 {
1628   guestfs_h *g;
1629   Data_Get_Struct (gv, guestfs_h, g);
1630   if (!g)
1631     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
1632
1633   const char *path = StringValueCStr (pathv);
1634   if (!path)
1635     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1636               "path", "statvfs");
1637
1638   struct guestfs_statvfs *r;
1639
1640   r = guestfs_statvfs (g, path);
1641   if (r == NULL)
1642     rb_raise (e_Error, "%s", guestfs_last_error (g));
1643
1644   VALUE rv = rb_hash_new ();
1645   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
1646   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
1647   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1648   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
1649   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
1650   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
1651   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
1652   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
1653   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
1654   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
1655   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
1656   free (r);
1657   return rv;
1658 }
1659
1660 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
1661 {
1662   guestfs_h *g;
1663   Data_Get_Struct (gv, guestfs_h, g);
1664   if (!g)
1665     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
1666
1667   const char *device = StringValueCStr (devicev);
1668   if (!device)
1669     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1670               "device", "tune2fs_l");
1671
1672   char **r;
1673
1674   r = guestfs_tune2fs_l (g, device);
1675   if (r == NULL)
1676     rb_raise (e_Error, "%s", guestfs_last_error (g));
1677
1678   VALUE rv = rb_hash_new ();
1679   int i;
1680   for (i = 0; r[i] != NULL; i+=2) {
1681     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
1682     free (r[i]);
1683     free (r[i+1]);
1684   }
1685   free (r);
1686   return rv;
1687 }
1688
1689 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
1690 {
1691   guestfs_h *g;
1692   Data_Get_Struct (gv, guestfs_h, g);
1693   if (!g)
1694     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
1695
1696   const char *device = StringValueCStr (devicev);
1697   if (!device)
1698     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1699               "device", "blockdev_setro");
1700
1701   int r;
1702
1703   r = guestfs_blockdev_setro (g, device);
1704   if (r == -1)
1705     rb_raise (e_Error, "%s", guestfs_last_error (g));
1706
1707   return Qnil;
1708 }
1709
1710 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
1711 {
1712   guestfs_h *g;
1713   Data_Get_Struct (gv, guestfs_h, g);
1714   if (!g)
1715     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
1716
1717   const char *device = StringValueCStr (devicev);
1718   if (!device)
1719     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1720               "device", "blockdev_setrw");
1721
1722   int r;
1723
1724   r = guestfs_blockdev_setrw (g, device);
1725   if (r == -1)
1726     rb_raise (e_Error, "%s", guestfs_last_error (g));
1727
1728   return Qnil;
1729 }
1730
1731 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
1732 {
1733   guestfs_h *g;
1734   Data_Get_Struct (gv, guestfs_h, g);
1735   if (!g)
1736     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
1737
1738   const char *device = StringValueCStr (devicev);
1739   if (!device)
1740     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1741               "device", "blockdev_getro");
1742
1743   int r;
1744
1745   r = guestfs_blockdev_getro (g, device);
1746   if (r == -1)
1747     rb_raise (e_Error, "%s", guestfs_last_error (g));
1748
1749   return INT2NUM (r);
1750 }
1751
1752 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
1753 {
1754   guestfs_h *g;
1755   Data_Get_Struct (gv, guestfs_h, g);
1756   if (!g)
1757     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
1758
1759   const char *device = StringValueCStr (devicev);
1760   if (!device)
1761     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1762               "device", "blockdev_getss");
1763
1764   int r;
1765
1766   r = guestfs_blockdev_getss (g, device);
1767   if (r == -1)
1768     rb_raise (e_Error, "%s", guestfs_last_error (g));
1769
1770   return INT2NUM (r);
1771 }
1772
1773 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
1774 {
1775   guestfs_h *g;
1776   Data_Get_Struct (gv, guestfs_h, g);
1777   if (!g)
1778     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
1779
1780   const char *device = StringValueCStr (devicev);
1781   if (!device)
1782     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1783               "device", "blockdev_getbsz");
1784
1785   int r;
1786
1787   r = guestfs_blockdev_getbsz (g, device);
1788   if (r == -1)
1789     rb_raise (e_Error, "%s", guestfs_last_error (g));
1790
1791   return INT2NUM (r);
1792 }
1793
1794 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
1795 {
1796   guestfs_h *g;
1797   Data_Get_Struct (gv, guestfs_h, g);
1798   if (!g)
1799     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
1800
1801   const char *device = StringValueCStr (devicev);
1802   if (!device)
1803     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1804               "device", "blockdev_setbsz");
1805   int blocksize = NUM2INT (blocksizev);
1806
1807   int r;
1808
1809   r = guestfs_blockdev_setbsz (g, device, blocksize);
1810   if (r == -1)
1811     rb_raise (e_Error, "%s", guestfs_last_error (g));
1812
1813   return Qnil;
1814 }
1815
1816 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
1817 {
1818   guestfs_h *g;
1819   Data_Get_Struct (gv, guestfs_h, g);
1820   if (!g)
1821     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
1822
1823   const char *device = StringValueCStr (devicev);
1824   if (!device)
1825     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1826               "device", "blockdev_getsz");
1827
1828   int64_t r;
1829
1830   r = guestfs_blockdev_getsz (g, device);
1831   if (r == -1)
1832     rb_raise (e_Error, "%s", guestfs_last_error (g));
1833
1834   return ULL2NUM (r);
1835 }
1836
1837 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
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", "blockdev_getsize64");
1843
1844   const char *device = StringValueCStr (devicev);
1845   if (!device)
1846     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1847               "device", "blockdev_getsize64");
1848
1849   int64_t r;
1850
1851   r = guestfs_blockdev_getsize64 (g, device);
1852   if (r == -1)
1853     rb_raise (e_Error, "%s", guestfs_last_error (g));
1854
1855   return ULL2NUM (r);
1856 }
1857
1858 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
1859 {
1860   guestfs_h *g;
1861   Data_Get_Struct (gv, guestfs_h, g);
1862   if (!g)
1863     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
1864
1865   const char *device = StringValueCStr (devicev);
1866   if (!device)
1867     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1868               "device", "blockdev_flushbufs");
1869
1870   int r;
1871
1872   r = guestfs_blockdev_flushbufs (g, device);
1873   if (r == -1)
1874     rb_raise (e_Error, "%s", guestfs_last_error (g));
1875
1876   return Qnil;
1877 }
1878
1879 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
1880 {
1881   guestfs_h *g;
1882   Data_Get_Struct (gv, guestfs_h, g);
1883   if (!g)
1884     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
1885
1886   const char *device = StringValueCStr (devicev);
1887   if (!device)
1888     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1889               "device", "blockdev_rereadpt");
1890
1891   int r;
1892
1893   r = guestfs_blockdev_rereadpt (g, device);
1894   if (r == -1)
1895     rb_raise (e_Error, "%s", guestfs_last_error (g));
1896
1897   return Qnil;
1898 }
1899
1900 /* Initialize the module. */
1901 void Init__guestfs ()
1902 {
1903   m_guestfs = rb_define_module ("Guestfs");
1904   c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
1905   e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
1906
1907   rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
1908   rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
1909
1910   rb_define_method (c_guestfs, "launch",
1911         ruby_guestfs_launch, 0);
1912   rb_define_method (c_guestfs, "wait_ready",
1913         ruby_guestfs_wait_ready, 0);
1914   rb_define_method (c_guestfs, "kill_subprocess",
1915         ruby_guestfs_kill_subprocess, 0);
1916   rb_define_method (c_guestfs, "add_drive",
1917         ruby_guestfs_add_drive, 1);
1918   rb_define_method (c_guestfs, "add_cdrom",
1919         ruby_guestfs_add_cdrom, 1);
1920   rb_define_method (c_guestfs, "config",
1921         ruby_guestfs_config, 2);
1922   rb_define_method (c_guestfs, "set_path",
1923         ruby_guestfs_set_path, 1);
1924   rb_define_method (c_guestfs, "get_path",
1925         ruby_guestfs_get_path, 0);
1926   rb_define_method (c_guestfs, "set_autosync",
1927         ruby_guestfs_set_autosync, 1);
1928   rb_define_method (c_guestfs, "get_autosync",
1929         ruby_guestfs_get_autosync, 0);
1930   rb_define_method (c_guestfs, "set_verbose",
1931         ruby_guestfs_set_verbose, 1);
1932   rb_define_method (c_guestfs, "get_verbose",
1933         ruby_guestfs_get_verbose, 0);
1934   rb_define_method (c_guestfs, "mount",
1935         ruby_guestfs_mount, 2);
1936   rb_define_method (c_guestfs, "sync",
1937         ruby_guestfs_sync, 0);
1938   rb_define_method (c_guestfs, "touch",
1939         ruby_guestfs_touch, 1);
1940   rb_define_method (c_guestfs, "cat",
1941         ruby_guestfs_cat, 1);
1942   rb_define_method (c_guestfs, "ll",
1943         ruby_guestfs_ll, 1);
1944   rb_define_method (c_guestfs, "ls",
1945         ruby_guestfs_ls, 1);
1946   rb_define_method (c_guestfs, "list_devices",
1947         ruby_guestfs_list_devices, 0);
1948   rb_define_method (c_guestfs, "list_partitions",
1949         ruby_guestfs_list_partitions, 0);
1950   rb_define_method (c_guestfs, "pvs",
1951         ruby_guestfs_pvs, 0);
1952   rb_define_method (c_guestfs, "vgs",
1953         ruby_guestfs_vgs, 0);
1954   rb_define_method (c_guestfs, "lvs",
1955         ruby_guestfs_lvs, 0);
1956   rb_define_method (c_guestfs, "pvs_full",
1957         ruby_guestfs_pvs_full, 0);
1958   rb_define_method (c_guestfs, "vgs_full",
1959         ruby_guestfs_vgs_full, 0);
1960   rb_define_method (c_guestfs, "lvs_full",
1961         ruby_guestfs_lvs_full, 0);
1962   rb_define_method (c_guestfs, "read_lines",
1963         ruby_guestfs_read_lines, 1);
1964   rb_define_method (c_guestfs, "aug_init",
1965         ruby_guestfs_aug_init, 2);
1966   rb_define_method (c_guestfs, "aug_close",
1967         ruby_guestfs_aug_close, 0);
1968   rb_define_method (c_guestfs, "aug_defvar",
1969         ruby_guestfs_aug_defvar, 2);
1970   rb_define_method (c_guestfs, "aug_defnode",
1971         ruby_guestfs_aug_defnode, 3);
1972   rb_define_method (c_guestfs, "aug_get",
1973         ruby_guestfs_aug_get, 1);
1974   rb_define_method (c_guestfs, "aug_set",
1975         ruby_guestfs_aug_set, 2);
1976   rb_define_method (c_guestfs, "aug_insert",
1977         ruby_guestfs_aug_insert, 3);
1978   rb_define_method (c_guestfs, "aug_rm",
1979         ruby_guestfs_aug_rm, 1);
1980   rb_define_method (c_guestfs, "aug_mv",
1981         ruby_guestfs_aug_mv, 2);
1982   rb_define_method (c_guestfs, "aug_match",
1983         ruby_guestfs_aug_match, 1);
1984   rb_define_method (c_guestfs, "aug_save",
1985         ruby_guestfs_aug_save, 0);
1986   rb_define_method (c_guestfs, "aug_load",
1987         ruby_guestfs_aug_load, 0);
1988   rb_define_method (c_guestfs, "aug_ls",
1989         ruby_guestfs_aug_ls, 1);
1990   rb_define_method (c_guestfs, "rm",
1991         ruby_guestfs_rm, 1);
1992   rb_define_method (c_guestfs, "rmdir",
1993         ruby_guestfs_rmdir, 1);
1994   rb_define_method (c_guestfs, "rm_rf",
1995         ruby_guestfs_rm_rf, 1);
1996   rb_define_method (c_guestfs, "mkdir",
1997         ruby_guestfs_mkdir, 1);
1998   rb_define_method (c_guestfs, "mkdir_p",
1999         ruby_guestfs_mkdir_p, 1);
2000   rb_define_method (c_guestfs, "chmod",
2001         ruby_guestfs_chmod, 2);
2002   rb_define_method (c_guestfs, "chown",
2003         ruby_guestfs_chown, 3);
2004   rb_define_method (c_guestfs, "exists",
2005         ruby_guestfs_exists, 1);
2006   rb_define_method (c_guestfs, "is_file",
2007         ruby_guestfs_is_file, 1);
2008   rb_define_method (c_guestfs, "is_dir",
2009         ruby_guestfs_is_dir, 1);
2010   rb_define_method (c_guestfs, "pvcreate",
2011         ruby_guestfs_pvcreate, 1);
2012   rb_define_method (c_guestfs, "vgcreate",
2013         ruby_guestfs_vgcreate, 2);
2014   rb_define_method (c_guestfs, "lvcreate",
2015         ruby_guestfs_lvcreate, 3);
2016   rb_define_method (c_guestfs, "mkfs",
2017         ruby_guestfs_mkfs, 2);
2018   rb_define_method (c_guestfs, "sfdisk",
2019         ruby_guestfs_sfdisk, 5);
2020   rb_define_method (c_guestfs, "write_file",
2021         ruby_guestfs_write_file, 3);
2022   rb_define_method (c_guestfs, "umount",
2023         ruby_guestfs_umount, 1);
2024   rb_define_method (c_guestfs, "mounts",
2025         ruby_guestfs_mounts, 0);
2026   rb_define_method (c_guestfs, "umount_all",
2027         ruby_guestfs_umount_all, 0);
2028   rb_define_method (c_guestfs, "lvm_remove_all",
2029         ruby_guestfs_lvm_remove_all, 0);
2030   rb_define_method (c_guestfs, "file",
2031         ruby_guestfs_file, 1);
2032   rb_define_method (c_guestfs, "command",
2033         ruby_guestfs_command, 1);
2034   rb_define_method (c_guestfs, "command_lines",
2035         ruby_guestfs_command_lines, 1);
2036   rb_define_method (c_guestfs, "stat",
2037         ruby_guestfs_stat, 1);
2038   rb_define_method (c_guestfs, "lstat",
2039         ruby_guestfs_lstat, 1);
2040   rb_define_method (c_guestfs, "statvfs",
2041         ruby_guestfs_statvfs, 1);
2042   rb_define_method (c_guestfs, "tune2fs_l",
2043         ruby_guestfs_tune2fs_l, 1);
2044   rb_define_method (c_guestfs, "blockdev_setro",
2045         ruby_guestfs_blockdev_setro, 1);
2046   rb_define_method (c_guestfs, "blockdev_setrw",
2047         ruby_guestfs_blockdev_setrw, 1);
2048   rb_define_method (c_guestfs, "blockdev_getro",
2049         ruby_guestfs_blockdev_getro, 1);
2050   rb_define_method (c_guestfs, "blockdev_getss",
2051         ruby_guestfs_blockdev_getss, 1);
2052   rb_define_method (c_guestfs, "blockdev_getbsz",
2053         ruby_guestfs_blockdev_getbsz, 1);
2054   rb_define_method (c_guestfs, "blockdev_setbsz",
2055         ruby_guestfs_blockdev_setbsz, 2);
2056   rb_define_method (c_guestfs, "blockdev_getsz",
2057         ruby_guestfs_blockdev_getsz, 1);
2058   rb_define_method (c_guestfs, "blockdev_getsize64",
2059         ruby_guestfs_blockdev_getsize64, 1);
2060   rb_define_method (c_guestfs, "blockdev_flushbufs",
2061         ruby_guestfs_blockdev_flushbufs, 1);
2062   rb_define_method (c_guestfs, "blockdev_rereadpt",
2063         ruby_guestfs_blockdev_rereadpt, 1);
2064 }