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_launch (VALUE gv)
  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", "launch");
  80
  81
  82   int r;
  83
  84   r = guestfs_launch (g);
  85   if (r == -1)
  86     rb_raise (e_Error, "%s", guestfs_last_error (g));
  87
  88   return Qnil;
  89 }
  90
  91 static VALUE ruby_guestfs_wait_ready (VALUE gv)
  92 {
  93   guestfs_h *g;
  94   Data_Get_Struct (gv, guestfs_h, g);
  95   if (!g)
  96     rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
  97
  98
  99   int r;
 100
 101   r = guestfs_wait_ready (g);
 102   if (r == -1)
 103     rb_raise (e_Error, "%s", guestfs_last_error (g));
 104
 105   return Qnil;
 106 }
 107
 108 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
 109 {
 110   guestfs_h *g;
 111   Data_Get_Struct (gv, guestfs_h, g);
 112   if (!g)
 113     rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
 114
 115
 116   int r;
 117
 118   r = guestfs_kill_subprocess (g);
 119   if (r == -1)
 120     rb_raise (e_Error, "%s", guestfs_last_error (g));
 121
 122   return Qnil;
 123 }
 124
 125 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
 126 {
 127   guestfs_h *g;
 128   Data_Get_Struct (gv, guestfs_h, g);
 129   if (!g)
 130     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
 131
 132   const char *filename = StringValueCStr (filenamev);
 133   if (!filename)
 134     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 135               "filename", "add_drive");
 136
 137   int r;
 138
 139   r = guestfs_add_drive (g, filename);
 140   if (r == -1)
 141     rb_raise (e_Error, "%s", guestfs_last_error (g));
 142
 143   return Qnil;
 144 }
 145
 146 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
 147 {
 148   guestfs_h *g;
 149   Data_Get_Struct (gv, guestfs_h, g);
 150   if (!g)
 151     rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
 152
 153   const char *filename = StringValueCStr (filenamev);
 154   if (!filename)
 155     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 156               "filename", "add_cdrom");
 157
 158   int r;
 159
 160   r = guestfs_add_cdrom (g, filename);
 161   if (r == -1)
 162     rb_raise (e_Error, "%s", guestfs_last_error (g));
 163
 164   return Qnil;
 165 }
 166
 167 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
 168 {
 169   guestfs_h *g;
 170   Data_Get_Struct (gv, guestfs_h, g);
 171   if (!g)
 172     rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
 173
 174   const char *qemuparam = StringValueCStr (qemuparamv);
 175   if (!qemuparam)
 176     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 177               "qemuparam", "config");
 178   const char *qemuvalue = StringValueCStr (qemuvaluev);
 179
 180   int r;
 181
 182   r = guestfs_config (g, qemuparam, qemuvalue);
 183   if (r == -1)
 184     rb_raise (e_Error, "%s", guestfs_last_error (g));
 185
 186   return Qnil;
 187 }
 188
 189 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
 190 {
 191   guestfs_h *g;
 192   Data_Get_Struct (gv, guestfs_h, g);
 193   if (!g)
 194     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
 195
 196   const char *qemu = StringValueCStr (qemuv);
 197   if (!qemu)
 198     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 199               "qemu", "set_qemu");
 200
 201   int r;
 202
 203   r = guestfs_set_qemu (g, qemu);
 204   if (r == -1)
 205     rb_raise (e_Error, "%s", guestfs_last_error (g));
 206
 207   return Qnil;
 208 }
 209
 210 static VALUE ruby_guestfs_get_qemu (VALUE gv)
 211 {
 212   guestfs_h *g;
 213   Data_Get_Struct (gv, guestfs_h, g);
 214   if (!g)
 215     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
 216
 217
 218   const char *r;
 219
 220   r = guestfs_get_qemu (g);
 221   if (r == NULL)
 222     rb_raise (e_Error, "%s", guestfs_last_error (g));
 223
 224   return rb_str_new2 (r);
 225 }
 226
 227 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
 228 {
 229   guestfs_h *g;
 230   Data_Get_Struct (gv, guestfs_h, g);
 231   if (!g)
 232     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
 233
 234   const char *path = StringValueCStr (pathv);
 235   if (!path)
 236     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 237               "path", "set_path");
 238
 239   int r;
 240
 241   r = guestfs_set_path (g, path);
 242   if (r == -1)
 243     rb_raise (e_Error, "%s", guestfs_last_error (g));
 244
 245   return Qnil;
 246 }
 247
 248 static VALUE ruby_guestfs_get_path (VALUE gv)
 249 {
 250   guestfs_h *g;
 251   Data_Get_Struct (gv, guestfs_h, g);
 252   if (!g)
 253     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
 254
 255
 256   const char *r;
 257
 258   r = guestfs_get_path (g);
 259   if (r == NULL)
 260     rb_raise (e_Error, "%s", guestfs_last_error (g));
 261
 262   return rb_str_new2 (r);
 263 }
 264
 265 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
 266 {
 267   guestfs_h *g;
 268   Data_Get_Struct (gv, guestfs_h, g);
 269   if (!g)
 270     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
 271
 272   int autosync = NUM2INT (autosyncv);
 273
 274   int r;
 275
 276   r = guestfs_set_autosync (g, autosync);
 277   if (r == -1)
 278     rb_raise (e_Error, "%s", guestfs_last_error (g));
 279
 280   return Qnil;
 281 }
 282
 283 static VALUE ruby_guestfs_get_autosync (VALUE gv)
 284 {
 285   guestfs_h *g;
 286   Data_Get_Struct (gv, guestfs_h, g);
 287   if (!g)
 288     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
 289
 290
 291   int r;
 292
 293   r = guestfs_get_autosync (g);
 294   if (r == -1)
 295     rb_raise (e_Error, "%s", guestfs_last_error (g));
 296
 297   return INT2NUM (r);
 298 }
 299
 300 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
 301 {
 302   guestfs_h *g;
 303   Data_Get_Struct (gv, guestfs_h, g);
 304   if (!g)
 305     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
 306
 307   int verbose = NUM2INT (verbosev);
 308
 309   int r;
 310
 311   r = guestfs_set_verbose (g, verbose);
 312   if (r == -1)
 313     rb_raise (e_Error, "%s", guestfs_last_error (g));
 314
 315   return Qnil;
 316 }
 317
 318 static VALUE ruby_guestfs_get_verbose (VALUE gv)
 319 {
 320   guestfs_h *g;
 321   Data_Get_Struct (gv, guestfs_h, g);
 322   if (!g)
 323     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
 324
 325
 326   int r;
 327
 328   r = guestfs_get_verbose (g);
 329   if (r == -1)
 330     rb_raise (e_Error, "%s", guestfs_last_error (g));
 331
 332   return INT2NUM (r);
 333 }
 334
 335 static VALUE ruby_guestfs_is_ready (VALUE gv)
 336 {
 337   guestfs_h *g;
 338   Data_Get_Struct (gv, guestfs_h, g);
 339   if (!g)
 340     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
 341
 342
 343   int r;
 344
 345   r = guestfs_is_ready (g);
 346   if (r == -1)
 347     rb_raise (e_Error, "%s", guestfs_last_error (g));
 348
 349   return INT2NUM (r);
 350 }
 351
 352 static VALUE ruby_guestfs_is_config (VALUE gv)
 353 {
 354   guestfs_h *g;
 355   Data_Get_Struct (gv, guestfs_h, g);
 356   if (!g)
 357     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
 358
 359
 360   int r;
 361
 362   r = guestfs_is_config (g);
 363   if (r == -1)
 364     rb_raise (e_Error, "%s", guestfs_last_error (g));
 365
 366   return INT2NUM (r);
 367 }
 368
 369 static VALUE ruby_guestfs_is_launching (VALUE gv)
 370 {
 371   guestfs_h *g;
 372   Data_Get_Struct (gv, guestfs_h, g);
 373   if (!g)
 374     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
 375
 376
 377   int r;
 378
 379   r = guestfs_is_launching (g);
 380   if (r == -1)
 381     rb_raise (e_Error, "%s", guestfs_last_error (g));
 382
 383   return INT2NUM (r);
 384 }
 385
 386 static VALUE ruby_guestfs_is_busy (VALUE gv)
 387 {
 388   guestfs_h *g;
 389   Data_Get_Struct (gv, guestfs_h, g);
 390   if (!g)
 391     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
 392
 393
 394   int r;
 395
 396   r = guestfs_is_busy (g);
 397   if (r == -1)
 398     rb_raise (e_Error, "%s", guestfs_last_error (g));
 399
 400   return INT2NUM (r);
 401 }
 402
 403 static VALUE ruby_guestfs_get_state (VALUE gv)
 404 {
 405   guestfs_h *g;
 406   Data_Get_Struct (gv, guestfs_h, g);
 407   if (!g)
 408     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
 409
 410
 411   int r;
 412
 413   r = guestfs_get_state (g);
 414   if (r == -1)
 415     rb_raise (e_Error, "%s", guestfs_last_error (g));
 416
 417   return INT2NUM (r);
 418 }
 419
 420 static VALUE ruby_guestfs_set_busy (VALUE gv)
 421 {
 422   guestfs_h *g;
 423   Data_Get_Struct (gv, guestfs_h, g);
 424   if (!g)
 425     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
 426
 427
 428   int r;
 429
 430   r = guestfs_set_busy (g);
 431   if (r == -1)
 432     rb_raise (e_Error, "%s", guestfs_last_error (g));
 433
 434   return Qnil;
 435 }
 436
 437 static VALUE ruby_guestfs_set_ready (VALUE gv)
 438 {
 439   guestfs_h *g;
 440   Data_Get_Struct (gv, guestfs_h, g);
 441   if (!g)
 442     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
 443
 444
 445   int r;
 446
 447   r = guestfs_set_ready (g);
 448   if (r == -1)
 449     rb_raise (e_Error, "%s", guestfs_last_error (g));
 450
 451   return Qnil;
 452 }
 453
 454 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
 455 {
 456   guestfs_h *g;
 457   Data_Get_Struct (gv, guestfs_h, g);
 458   if (!g)
 459     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
 460
 461   const char *device = StringValueCStr (devicev);
 462   if (!device)
 463     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 464               "device", "mount");
 465   const char *mountpoint = StringValueCStr (mountpointv);
 466   if (!mountpoint)
 467     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 468               "mountpoint", "mount");
 469
 470   int r;
 471
 472   r = guestfs_mount (g, device, mountpoint);
 473   if (r == -1)
 474     rb_raise (e_Error, "%s", guestfs_last_error (g));
 475
 476   return Qnil;
 477 }
 478
 479 static VALUE ruby_guestfs_sync (VALUE gv)
 480 {
 481   guestfs_h *g;
 482   Data_Get_Struct (gv, guestfs_h, g);
 483   if (!g)
 484     rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
 485
 486
 487   int r;
 488
 489   r = guestfs_sync (g);
 490   if (r == -1)
 491     rb_raise (e_Error, "%s", guestfs_last_error (g));
 492
 493   return Qnil;
 494 }
 495
 496 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
 497 {
 498   guestfs_h *g;
 499   Data_Get_Struct (gv, guestfs_h, g);
 500   if (!g)
 501     rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
 502
 503   const char *path = StringValueCStr (pathv);
 504   if (!path)
 505     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 506               "path", "touch");
 507
 508   int r;
 509
 510   r = guestfs_touch (g, path);
 511   if (r == -1)
 512     rb_raise (e_Error, "%s", guestfs_last_error (g));
 513
 514   return Qnil;
 515 }
 516
 517 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
 518 {
 519   guestfs_h *g;
 520   Data_Get_Struct (gv, guestfs_h, g);
 521   if (!g)
 522     rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
 523
 524   const char *path = StringValueCStr (pathv);
 525   if (!path)
 526     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 527               "path", "cat");
 528
 529   char *r;
 530
 531   r = guestfs_cat (g, path);
 532   if (r == NULL)
 533     rb_raise (e_Error, "%s", guestfs_last_error (g));
 534
 535   VALUE rv = rb_str_new2 (r);
 536   free (r);
 537   return rv;
 538 }
 539
 540 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
 541 {
 542   guestfs_h *g;
 543   Data_Get_Struct (gv, guestfs_h, g);
 544   if (!g)
 545     rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
 546
 547   const char *directory = StringValueCStr (directoryv);
 548   if (!directory)
 549     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 550               "directory", "ll");
 551
 552   char *r;
 553
 554   r = guestfs_ll (g, directory);
 555   if (r == NULL)
 556     rb_raise (e_Error, "%s", guestfs_last_error (g));
 557
 558   VALUE rv = rb_str_new2 (r);
 559   free (r);
 560   return rv;
 561 }
 562
 563 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
 564 {
 565   guestfs_h *g;
 566   Data_Get_Struct (gv, guestfs_h, g);
 567   if (!g)
 568     rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
 569
 570   const char *directory = StringValueCStr (directoryv);
 571   if (!directory)
 572     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 573               "directory", "ls");
 574
 575   char **r;
 576
 577   r = guestfs_ls (g, directory);
 578   if (r == NULL)
 579     rb_raise (e_Error, "%s", guestfs_last_error (g));
 580
 581   int i, len = 0;
 582   for (i = 0; r[i] != NULL; ++i) len++;
 583   VALUE rv = rb_ary_new2 (len);
 584   for (i = 0; r[i] != NULL; ++i) {
 585     rb_ary_push (rv, rb_str_new2 (r[i]));
 586     free (r[i]);
 587   }
 588   free (r);
 589   return rv;
 590 }
 591
 592 static VALUE ruby_guestfs_list_devices (VALUE gv)
 593 {
 594   guestfs_h *g;
 595   Data_Get_Struct (gv, guestfs_h, g);
 596   if (!g)
 597     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
 598
 599
 600   char **r;
 601
 602   r = guestfs_list_devices (g);
 603   if (r == NULL)
 604     rb_raise (e_Error, "%s", guestfs_last_error (g));
 605
 606   int i, len = 0;
 607   for (i = 0; r[i] != NULL; ++i) len++;
 608   VALUE rv = rb_ary_new2 (len);
 609   for (i = 0; r[i] != NULL; ++i) {
 610     rb_ary_push (rv, rb_str_new2 (r[i]));
 611     free (r[i]);
 612   }
 613   free (r);
 614   return rv;
 615 }
 616
 617 static VALUE ruby_guestfs_list_partitions (VALUE gv)
 618 {
 619   guestfs_h *g;
 620   Data_Get_Struct (gv, guestfs_h, g);
 621   if (!g)
 622     rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
 623
 624
 625   char **r;
 626
 627   r = guestfs_list_partitions (g);
 628   if (r == NULL)
 629     rb_raise (e_Error, "%s", guestfs_last_error (g));
 630
 631   int i, len = 0;
 632   for (i = 0; r[i] != NULL; ++i) len++;
 633   VALUE rv = rb_ary_new2 (len);
 634   for (i = 0; r[i] != NULL; ++i) {
 635     rb_ary_push (rv, rb_str_new2 (r[i]));
 636     free (r[i]);
 637   }
 638   free (r);
 639   return rv;
 640 }
 641
 642 static VALUE ruby_guestfs_pvs (VALUE gv)
 643 {
 644   guestfs_h *g;
 645   Data_Get_Struct (gv, guestfs_h, g);
 646   if (!g)
 647     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
 648
 649
 650   char **r;
 651
 652   r = guestfs_pvs (g);
 653   if (r == NULL)
 654     rb_raise (e_Error, "%s", guestfs_last_error (g));
 655
 656   int i, len = 0;
 657   for (i = 0; r[i] != NULL; ++i) len++;
 658   VALUE rv = rb_ary_new2 (len);
 659   for (i = 0; r[i] != NULL; ++i) {
 660     rb_ary_push (rv, rb_str_new2 (r[i]));
 661     free (r[i]);
 662   }
 663   free (r);
 664   return rv;
 665 }
 666
 667 static VALUE ruby_guestfs_vgs (VALUE gv)
 668 {
 669   guestfs_h *g;
 670   Data_Get_Struct (gv, guestfs_h, g);
 671   if (!g)
 672     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
 673
 674
 675   char **r;
 676
 677   r = guestfs_vgs (g);
 678   if (r == NULL)
 679     rb_raise (e_Error, "%s", guestfs_last_error (g));
 680
 681   int i, len = 0;
 682   for (i = 0; r[i] != NULL; ++i) len++;
 683   VALUE rv = rb_ary_new2 (len);
 684   for (i = 0; r[i] != NULL; ++i) {
 685     rb_ary_push (rv, rb_str_new2 (r[i]));
 686     free (r[i]);
 687   }
 688   free (r);
 689   return rv;
 690 }
 691
 692 static VALUE ruby_guestfs_lvs (VALUE gv)
 693 {
 694   guestfs_h *g;
 695   Data_Get_Struct (gv, guestfs_h, g);
 696   if (!g)
 697     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
 698
 699
 700   char **r;
 701
 702   r = guestfs_lvs (g);
 703   if (r == NULL)
 704     rb_raise (e_Error, "%s", guestfs_last_error (g));
 705
 706   int i, len = 0;
 707   for (i = 0; r[i] != NULL; ++i) len++;
 708   VALUE rv = rb_ary_new2 (len);
 709   for (i = 0; r[i] != NULL; ++i) {
 710     rb_ary_push (rv, rb_str_new2 (r[i]));
 711     free (r[i]);
 712   }
 713   free (r);
 714   return rv;
 715 }
 716
 717 static VALUE ruby_guestfs_pvs_full (VALUE gv)
 718 {
 719   guestfs_h *g;
 720   Data_Get_Struct (gv, guestfs_h, g);
 721   if (!g)
 722     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
 723
 724
 725   struct guestfs_lvm_pv_list *r;
 726
 727   r = guestfs_pvs_full (g);
 728   if (r == NULL)
 729     rb_raise (e_Error, "%s", guestfs_last_error (g));
 730
 731   VALUE rv = rb_ary_new2 (r->len);
 732   int i;
 733   for (i = 0; i < r->len; ++i) {
 734     VALUE hv = rb_hash_new ();
 735     rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
 736     rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
 737     rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
 738     rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
 739     rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
 740     rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
 741     rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
 742     rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
 743     rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
 744     rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
 745     rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
 746     rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
 747     rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
 748     rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
 749     rb_ary_push (rv, hv);
 750   }
 751   guestfs_free_lvm_pv_list (r);
 752   return rv;
 753 }
 754
 755 static VALUE ruby_guestfs_vgs_full (VALUE gv)
 756 {
 757   guestfs_h *g;
 758   Data_Get_Struct (gv, guestfs_h, g);
 759   if (!g)
 760     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
 761
 762
 763   struct guestfs_lvm_vg_list *r;
 764
 765   r = guestfs_vgs_full (g);
 766   if (r == NULL)
 767     rb_raise (e_Error, "%s", guestfs_last_error (g));
 768
 769   VALUE rv = rb_ary_new2 (r->len);
 770   int i;
 771   for (i = 0; i < r->len; ++i) {
 772     VALUE hv = rb_hash_new ();
 773     rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
 774     rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
 775     rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
 776     rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
 777     rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
 778     rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
 779     rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
 780     rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
 781     rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
 782     rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
 783     rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
 784     rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
 785     rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
 786     rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
 787     rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
 788     rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
 789     rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
 790     rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
 791     rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
 792     rb_ary_push (rv, hv);
 793   }
 794   guestfs_free_lvm_vg_list (r);
 795   return rv;
 796 }
 797
 798 static VALUE ruby_guestfs_lvs_full (VALUE gv)
 799 {
 800   guestfs_h *g;
 801   Data_Get_Struct (gv, guestfs_h, g);
 802   if (!g)
 803     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
 804
 805
 806   struct guestfs_lvm_lv_list *r;
 807
 808   r = guestfs_lvs_full (g);
 809   if (r == NULL)
 810     rb_raise (e_Error, "%s", guestfs_last_error (g));
 811
 812   VALUE rv = rb_ary_new2 (r->len);
 813   int i;
 814   for (i = 0; i < r->len; ++i) {
 815     VALUE hv = rb_hash_new ();
 816     rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
 817     rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
 818     rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
 819     rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
 820     rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
 821     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
 822     rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
 823     rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
 824     rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
 825     rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
 826     rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
 827     rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
 828     rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
 829     rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
 830     rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
 831     rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
 832     rb_ary_push (rv, hv);
 833   }
 834   guestfs_free_lvm_lv_list (r);
 835   return rv;
 836 }
 837
 838 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
 839 {
 840   guestfs_h *g;
 841   Data_Get_Struct (gv, guestfs_h, g);
 842   if (!g)
 843     rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
 844
 845   const char *path = StringValueCStr (pathv);
 846   if (!path)
 847     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 848               "path", "read_lines");
 849
 850   char **r;
 851
 852   r = guestfs_read_lines (g, path);
 853   if (r == NULL)
 854     rb_raise (e_Error, "%s", guestfs_last_error (g));
 855
 856   int i, len = 0;
 857   for (i = 0; r[i] != NULL; ++i) len++;
 858   VALUE rv = rb_ary_new2 (len);
 859   for (i = 0; r[i] != NULL; ++i) {
 860     rb_ary_push (rv, rb_str_new2 (r[i]));
 861     free (r[i]);
 862   }
 863   free (r);
 864   return rv;
 865 }
 866
 867 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
 868 {
 869   guestfs_h *g;
 870   Data_Get_Struct (gv, guestfs_h, g);
 871   if (!g)
 872     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
 873
 874   const char *root = StringValueCStr (rootv);
 875   if (!root)
 876     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 877               "root", "aug_init");
 878   int flags = NUM2INT (flagsv);
 879
 880   int r;
 881
 882   r = guestfs_aug_init (g, root, flags);
 883   if (r == -1)
 884     rb_raise (e_Error, "%s", guestfs_last_error (g));
 885
 886   return Qnil;
 887 }
 888
 889 static VALUE ruby_guestfs_aug_close (VALUE gv)
 890 {
 891   guestfs_h *g;
 892   Data_Get_Struct (gv, guestfs_h, g);
 893   if (!g)
 894     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
 895
 896
 897   int r;
 898
 899   r = guestfs_aug_close (g);
 900   if (r == -1)
 901     rb_raise (e_Error, "%s", guestfs_last_error (g));
 902
 903   return Qnil;
 904 }
 905
 906 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
 907 {
 908   guestfs_h *g;
 909   Data_Get_Struct (gv, guestfs_h, g);
 910   if (!g)
 911     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
 912
 913   const char *name = StringValueCStr (namev);
 914   if (!name)
 915     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 916               "name", "aug_defvar");
 917   const char *expr = StringValueCStr (exprv);
 918
 919   int r;
 920
 921   r = guestfs_aug_defvar (g, name, expr);
 922   if (r == -1)
 923     rb_raise (e_Error, "%s", guestfs_last_error (g));
 924
 925   return INT2NUM (r);
 926 }
 927
 928 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
 929 {
 930   guestfs_h *g;
 931   Data_Get_Struct (gv, guestfs_h, g);
 932   if (!g)
 933     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
 934
 935   const char *name = StringValueCStr (namev);
 936   if (!name)
 937     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 938               "name", "aug_defnode");
 939   const char *expr = StringValueCStr (exprv);
 940   if (!expr)
 941     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 942               "expr", "aug_defnode");
 943   const char *val = StringValueCStr (valv);
 944   if (!val)
 945     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 946               "val", "aug_defnode");
 947
 948   struct guestfs_int_bool *r;
 949
 950   r = guestfs_aug_defnode (g, name, expr, val);
 951   if (r == NULL)
 952     rb_raise (e_Error, "%s", guestfs_last_error (g));
 953
 954   VALUE rv = rb_ary_new2 (2);
 955   rb_ary_push (rv, INT2NUM (r->i));
 956   rb_ary_push (rv, INT2NUM (r->b));
 957   guestfs_free_int_bool (r);
 958   return rv;
 959 }
 960
 961 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
 962 {
 963   guestfs_h *g;
 964   Data_Get_Struct (gv, guestfs_h, g);
 965   if (!g)
 966     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
 967
 968   const char *path = StringValueCStr (pathv);
 969   if (!path)
 970     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 971               "path", "aug_get");
 972
 973   char *r;
 974
 975   r = guestfs_aug_get (g, path);
 976   if (r == NULL)
 977     rb_raise (e_Error, "%s", guestfs_last_error (g));
 978
 979   VALUE rv = rb_str_new2 (r);
 980   free (r);
 981   return rv;
 982 }
 983
 984 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
 985 {
 986   guestfs_h *g;
 987   Data_Get_Struct (gv, guestfs_h, g);
 988   if (!g)
 989     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
 990
 991   const char *path = StringValueCStr (pathv);
 992   if (!path)
 993     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 994               "path", "aug_set");
 995   const char *val = StringValueCStr (valv);
 996   if (!val)
 997     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
 998               "val", "aug_set");
 999
1000   int r;
1001
1002   r = guestfs_aug_set (g, path, val);
1003   if (r == -1)
1004     rb_raise (e_Error, "%s", guestfs_last_error (g));
1005
1006   return Qnil;
1007 }
1008
1009 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1010 {
1011   guestfs_h *g;
1012   Data_Get_Struct (gv, guestfs_h, g);
1013   if (!g)
1014     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1015
1016   const char *path = StringValueCStr (pathv);
1017   if (!path)
1018     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1019               "path", "aug_insert");
1020   const char *label = StringValueCStr (labelv);
1021   if (!label)
1022     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1023               "label", "aug_insert");
1024   int before = NUM2INT (beforev);
1025
1026   int r;
1027
1028   r = guestfs_aug_insert (g, path, label, before);
1029   if (r == -1)
1030     rb_raise (e_Error, "%s", guestfs_last_error (g));
1031
1032   return Qnil;
1033 }
1034
1035 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1036 {
1037   guestfs_h *g;
1038   Data_Get_Struct (gv, guestfs_h, g);
1039   if (!g)
1040     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1041
1042   const char *path = StringValueCStr (pathv);
1043   if (!path)
1044     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1045               "path", "aug_rm");
1046
1047   int r;
1048
1049   r = guestfs_aug_rm (g, path);
1050   if (r == -1)
1051     rb_raise (e_Error, "%s", guestfs_last_error (g));
1052
1053   return INT2NUM (r);
1054 }
1055
1056 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1057 {
1058   guestfs_h *g;
1059   Data_Get_Struct (gv, guestfs_h, g);
1060   if (!g)
1061     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1062
1063   const char *src = StringValueCStr (srcv);
1064   if (!src)
1065     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1066               "src", "aug_mv");
1067   const char *dest = StringValueCStr (destv);
1068   if (!dest)
1069     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1070               "dest", "aug_mv");
1071
1072   int r;
1073
1074   r = guestfs_aug_mv (g, src, dest);
1075   if (r == -1)
1076     rb_raise (e_Error, "%s", guestfs_last_error (g));
1077
1078   return Qnil;
1079 }
1080
1081 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1082 {
1083   guestfs_h *g;
1084   Data_Get_Struct (gv, guestfs_h, g);
1085   if (!g)
1086     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1087
1088   const char *path = StringValueCStr (pathv);
1089   if (!path)
1090     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1091               "path", "aug_match");
1092
1093   char **r;
1094
1095   r = guestfs_aug_match (g, path);
1096   if (r == NULL)
1097     rb_raise (e_Error, "%s", guestfs_last_error (g));
1098
1099   int i, len = 0;
1100   for (i = 0; r[i] != NULL; ++i) len++;
1101   VALUE rv = rb_ary_new2 (len);
1102   for (i = 0; r[i] != NULL; ++i) {
1103     rb_ary_push (rv, rb_str_new2 (r[i]));
1104     free (r[i]);
1105   }
1106   free (r);
1107   return rv;
1108 }
1109
1110 static VALUE ruby_guestfs_aug_save (VALUE gv)
1111 {
1112   guestfs_h *g;
1113   Data_Get_Struct (gv, guestfs_h, g);
1114   if (!g)
1115     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1116
1117
1118   int r;
1119
1120   r = guestfs_aug_save (g);
1121   if (r == -1)
1122     rb_raise (e_Error, "%s", guestfs_last_error (g));
1123
1124   return Qnil;
1125 }
1126
1127 static VALUE ruby_guestfs_aug_load (VALUE gv)
1128 {
1129   guestfs_h *g;
1130   Data_Get_Struct (gv, guestfs_h, g);
1131   if (!g)
1132     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1133
1134
1135   int r;
1136
1137   r = guestfs_aug_load (g);
1138   if (r == -1)
1139     rb_raise (e_Error, "%s", guestfs_last_error (g));
1140
1141   return Qnil;
1142 }
1143
1144 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1145 {
1146   guestfs_h *g;
1147   Data_Get_Struct (gv, guestfs_h, g);
1148   if (!g)
1149     rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
1150
1151   const char *path = StringValueCStr (pathv);
1152   if (!path)
1153     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1154               "path", "aug_ls");
1155
1156   char **r;
1157
1158   r = guestfs_aug_ls (g, path);
1159   if (r == NULL)
1160     rb_raise (e_Error, "%s", guestfs_last_error (g));
1161
1162   int i, len = 0;
1163   for (i = 0; r[i] != NULL; ++i) len++;
1164   VALUE rv = rb_ary_new2 (len);
1165   for (i = 0; r[i] != NULL; ++i) {
1166     rb_ary_push (rv, rb_str_new2 (r[i]));
1167     free (r[i]);
1168   }
1169   free (r);
1170   return rv;
1171 }
1172
1173 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
1174 {
1175   guestfs_h *g;
1176   Data_Get_Struct (gv, guestfs_h, g);
1177   if (!g)
1178     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
1179
1180   const char *path = StringValueCStr (pathv);
1181   if (!path)
1182     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1183               "path", "rm");
1184
1185   int r;
1186
1187   r = guestfs_rm (g, path);
1188   if (r == -1)
1189     rb_raise (e_Error, "%s", guestfs_last_error (g));
1190
1191   return Qnil;
1192 }
1193
1194 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
1195 {
1196   guestfs_h *g;
1197   Data_Get_Struct (gv, guestfs_h, g);
1198   if (!g)
1199     rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
1200
1201   const char *path = StringValueCStr (pathv);
1202   if (!path)
1203     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1204               "path", "rmdir");
1205
1206   int r;
1207
1208   r = guestfs_rmdir (g, path);
1209   if (r == -1)
1210     rb_raise (e_Error, "%s", guestfs_last_error (g));
1211
1212   return Qnil;
1213 }
1214
1215 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
1216 {
1217   guestfs_h *g;
1218   Data_Get_Struct (gv, guestfs_h, g);
1219   if (!g)
1220     rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
1221
1222   const char *path = StringValueCStr (pathv);
1223   if (!path)
1224     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1225               "path", "rm_rf");
1226
1227   int r;
1228
1229   r = guestfs_rm_rf (g, path);
1230   if (r == -1)
1231     rb_raise (e_Error, "%s", guestfs_last_error (g));
1232
1233   return Qnil;
1234 }
1235
1236 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
1237 {
1238   guestfs_h *g;
1239   Data_Get_Struct (gv, guestfs_h, g);
1240   if (!g)
1241     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
1242
1243   const char *path = StringValueCStr (pathv);
1244   if (!path)
1245     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1246               "path", "mkdir");
1247
1248   int r;
1249
1250   r = guestfs_mkdir (g, path);
1251   if (r == -1)
1252     rb_raise (e_Error, "%s", guestfs_last_error (g));
1253
1254   return Qnil;
1255 }
1256
1257 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
1258 {
1259   guestfs_h *g;
1260   Data_Get_Struct (gv, guestfs_h, g);
1261   if (!g)
1262     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
1263
1264   const char *path = StringValueCStr (pathv);
1265   if (!path)
1266     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1267               "path", "mkdir_p");
1268
1269   int r;
1270
1271   r = guestfs_mkdir_p (g, path);
1272   if (r == -1)
1273     rb_raise (e_Error, "%s", guestfs_last_error (g));
1274
1275   return Qnil;
1276 }
1277
1278 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
1279 {
1280   guestfs_h *g;
1281   Data_Get_Struct (gv, guestfs_h, g);
1282   if (!g)
1283     rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
1284
1285   int mode = NUM2INT (modev);
1286   const char *path = StringValueCStr (pathv);
1287   if (!path)
1288     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1289               "path", "chmod");
1290
1291   int r;
1292
1293   r = guestfs_chmod (g, mode, path);
1294   if (r == -1)
1295     rb_raise (e_Error, "%s", guestfs_last_error (g));
1296
1297   return Qnil;
1298 }
1299
1300 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
1301 {
1302   guestfs_h *g;
1303   Data_Get_Struct (gv, guestfs_h, g);
1304   if (!g)
1305     rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
1306
1307   int owner = NUM2INT (ownerv);
1308   int group = NUM2INT (groupv);
1309   const char *path = StringValueCStr (pathv);
1310   if (!path)
1311     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1312               "path", "chown");
1313
1314   int r;
1315
1316   r = guestfs_chown (g, owner, group, path);
1317   if (r == -1)
1318     rb_raise (e_Error, "%s", guestfs_last_error (g));
1319
1320   return Qnil;
1321 }
1322
1323 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
1324 {
1325   guestfs_h *g;
1326   Data_Get_Struct (gv, guestfs_h, g);
1327   if (!g)
1328     rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
1329
1330   const char *path = StringValueCStr (pathv);
1331   if (!path)
1332     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1333               "path", "exists");
1334
1335   int r;
1336
1337   r = guestfs_exists (g, path);
1338   if (r == -1)
1339     rb_raise (e_Error, "%s", guestfs_last_error (g));
1340
1341   return INT2NUM (r);
1342 }
1343
1344 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
1345 {
1346   guestfs_h *g;
1347   Data_Get_Struct (gv, guestfs_h, g);
1348   if (!g)
1349     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
1350
1351   const char *path = StringValueCStr (pathv);
1352   if (!path)
1353     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1354               "path", "is_file");
1355
1356   int r;
1357
1358   r = guestfs_is_file (g, path);
1359   if (r == -1)
1360     rb_raise (e_Error, "%s", guestfs_last_error (g));
1361
1362   return INT2NUM (r);
1363 }
1364
1365 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
1366 {
1367   guestfs_h *g;
1368   Data_Get_Struct (gv, guestfs_h, g);
1369   if (!g)
1370     rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
1371
1372   const char *path = StringValueCStr (pathv);
1373   if (!path)
1374     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1375               "path", "is_dir");
1376
1377   int r;
1378
1379   r = guestfs_is_dir (g, path);
1380   if (r == -1)
1381     rb_raise (e_Error, "%s", guestfs_last_error (g));
1382
1383   return INT2NUM (r);
1384 }
1385
1386 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
1387 {
1388   guestfs_h *g;
1389   Data_Get_Struct (gv, guestfs_h, g);
1390   if (!g)
1391     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
1392
1393   const char *device = StringValueCStr (devicev);
1394   if (!device)
1395     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1396               "device", "pvcreate");
1397
1398   int r;
1399
1400   r = guestfs_pvcreate (g, device);
1401   if (r == -1)
1402     rb_raise (e_Error, "%s", guestfs_last_error (g));
1403
1404   return Qnil;
1405 }
1406
1407 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
1408 {
1409   guestfs_h *g;
1410   Data_Get_Struct (gv, guestfs_h, g);
1411   if (!g)
1412     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
1413
1414   const char *volgroup = StringValueCStr (volgroupv);
1415   if (!volgroup)
1416     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1417               "volgroup", "vgcreate");
1418   char **physvols;  {
1419     int i, len;
1420     len = RARRAY_LEN (physvolsv);
1421     physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1422     for (i = 0; i < len; ++i) {
1423       VALUE v = rb_ary_entry (physvolsv, i);
1424       physvols[i] = StringValueCStr (v);
1425     }
1426     physvols[len] = NULL;
1427   }
1428
1429   int r;
1430
1431   r = guestfs_vgcreate (g, volgroup, physvols);
1432   free (physvols);
1433   if (r == -1)
1434     rb_raise (e_Error, "%s", guestfs_last_error (g));
1435
1436   return Qnil;
1437 }
1438
1439 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
1440 {
1441   guestfs_h *g;
1442   Data_Get_Struct (gv, guestfs_h, g);
1443   if (!g)
1444     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
1445
1446   const char *logvol = StringValueCStr (logvolv);
1447   if (!logvol)
1448     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1449               "logvol", "lvcreate");
1450   const char *volgroup = StringValueCStr (volgroupv);
1451   if (!volgroup)
1452     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1453               "volgroup", "lvcreate");
1454   int mbytes = NUM2INT (mbytesv);
1455
1456   int r;
1457
1458   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1459   if (r == -1)
1460     rb_raise (e_Error, "%s", guestfs_last_error (g));
1461
1462   return Qnil;
1463 }
1464
1465 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
1466 {
1467   guestfs_h *g;
1468   Data_Get_Struct (gv, guestfs_h, g);
1469   if (!g)
1470     rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
1471
1472   const char *fstype = StringValueCStr (fstypev);
1473   if (!fstype)
1474     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1475               "fstype", "mkfs");
1476   const char *device = StringValueCStr (devicev);
1477   if (!device)
1478     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1479               "device", "mkfs");
1480
1481   int r;
1482
1483   r = guestfs_mkfs (g, fstype, device);
1484   if (r == -1)
1485     rb_raise (e_Error, "%s", guestfs_last_error (g));
1486
1487   return Qnil;
1488 }
1489
1490 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
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", "sfdisk");
1496
1497   const char *device = StringValueCStr (devicev);
1498   if (!device)
1499     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1500               "device", "sfdisk");
1501   int cyls = NUM2INT (cylsv);
1502   int heads = NUM2INT (headsv);
1503   int sectors = NUM2INT (sectorsv);
1504   char **lines;  {
1505     int i, len;
1506     len = RARRAY_LEN (linesv);
1507     lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1508     for (i = 0; i < len; ++i) {
1509       VALUE v = rb_ary_entry (linesv, i);
1510       lines[i] = StringValueCStr (v);
1511     }
1512     lines[len] = NULL;
1513   }
1514
1515   int r;
1516
1517   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1518   free (lines);
1519   if (r == -1)
1520     rb_raise (e_Error, "%s", guestfs_last_error (g));
1521
1522   return Qnil;
1523 }
1524
1525 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
1526 {
1527   guestfs_h *g;
1528   Data_Get_Struct (gv, guestfs_h, g);
1529   if (!g)
1530     rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
1531
1532   const char *path = StringValueCStr (pathv);
1533   if (!path)
1534     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1535               "path", "write_file");
1536   const char *content = StringValueCStr (contentv);
1537   if (!content)
1538     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1539               "content", "write_file");
1540   int size = NUM2INT (sizev);
1541
1542   int r;
1543
1544   r = guestfs_write_file (g, path, content, size);
1545   if (r == -1)
1546     rb_raise (e_Error, "%s", guestfs_last_error (g));
1547
1548   return Qnil;
1549 }
1550
1551 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
1552 {
1553   guestfs_h *g;
1554   Data_Get_Struct (gv, guestfs_h, g);
1555   if (!g)
1556     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
1557
1558   const char *pathordevice = StringValueCStr (pathordevicev);
1559   if (!pathordevice)
1560     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1561               "pathordevice", "umount");
1562
1563   int r;
1564
1565   r = guestfs_umount (g, pathordevice);
1566   if (r == -1)
1567     rb_raise (e_Error, "%s", guestfs_last_error (g));
1568
1569   return Qnil;
1570 }
1571
1572 static VALUE ruby_guestfs_mounts (VALUE gv)
1573 {
1574   guestfs_h *g;
1575   Data_Get_Struct (gv, guestfs_h, g);
1576   if (!g)
1577     rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
1578
1579
1580   char **r;
1581
1582   r = guestfs_mounts (g);
1583   if (r == NULL)
1584     rb_raise (e_Error, "%s", guestfs_last_error (g));
1585
1586   int i, len = 0;
1587   for (i = 0; r[i] != NULL; ++i) len++;
1588   VALUE rv = rb_ary_new2 (len);
1589   for (i = 0; r[i] != NULL; ++i) {
1590     rb_ary_push (rv, rb_str_new2 (r[i]));
1591     free (r[i]);
1592   }
1593   free (r);
1594   return rv;
1595 }
1596
1597 static VALUE ruby_guestfs_umount_all (VALUE gv)
1598 {
1599   guestfs_h *g;
1600   Data_Get_Struct (gv, guestfs_h, g);
1601   if (!g)
1602     rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
1603
1604
1605   int r;
1606
1607   r = guestfs_umount_all (g);
1608   if (r == -1)
1609     rb_raise (e_Error, "%s", guestfs_last_error (g));
1610
1611   return Qnil;
1612 }
1613
1614 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
1615 {
1616   guestfs_h *g;
1617   Data_Get_Struct (gv, guestfs_h, g);
1618   if (!g)
1619     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
1620
1621
1622   int r;
1623
1624   r = guestfs_lvm_remove_all (g);
1625   if (r == -1)
1626     rb_raise (e_Error, "%s", guestfs_last_error (g));
1627
1628   return Qnil;
1629 }
1630
1631 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
1632 {
1633   guestfs_h *g;
1634   Data_Get_Struct (gv, guestfs_h, g);
1635   if (!g)
1636     rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
1637
1638   const char *path = StringValueCStr (pathv);
1639   if (!path)
1640     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1641               "path", "file");
1642
1643   char *r;
1644
1645   r = guestfs_file (g, path);
1646   if (r == NULL)
1647     rb_raise (e_Error, "%s", guestfs_last_error (g));
1648
1649   VALUE rv = rb_str_new2 (r);
1650   free (r);
1651   return rv;
1652 }
1653
1654 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
1655 {
1656   guestfs_h *g;
1657   Data_Get_Struct (gv, guestfs_h, g);
1658   if (!g)
1659     rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
1660
1661   char **arguments;  {
1662     int i, len;
1663     len = RARRAY_LEN (argumentsv);
1664     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1665     for (i = 0; i < len; ++i) {
1666       VALUE v = rb_ary_entry (argumentsv, i);
1667       arguments[i] = StringValueCStr (v);
1668     }
1669     arguments[len] = NULL;
1670   }
1671
1672   char *r;
1673
1674   r = guestfs_command (g, arguments);
1675   free (arguments);
1676   if (r == NULL)
1677     rb_raise (e_Error, "%s", guestfs_last_error (g));
1678
1679   VALUE rv = rb_str_new2 (r);
1680   free (r);
1681   return rv;
1682 }
1683
1684 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
1685 {
1686   guestfs_h *g;
1687   Data_Get_Struct (gv, guestfs_h, g);
1688   if (!g)
1689     rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
1690
1691   char **arguments;  {
1692     int i, len;
1693     len = RARRAY_LEN (argumentsv);
1694     arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1695     for (i = 0; i < len; ++i) {
1696       VALUE v = rb_ary_entry (argumentsv, i);
1697       arguments[i] = StringValueCStr (v);
1698     }
1699     arguments[len] = NULL;
1700   }
1701
1702   char **r;
1703
1704   r = guestfs_command_lines (g, arguments);
1705   free (arguments);
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_stat (VALUE gv, VALUE pathv)
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", "stat");
1726
1727   const char *path = StringValueCStr (pathv);
1728   if (!path)
1729     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1730               "path", "stat");
1731
1732   struct guestfs_stat *r;
1733
1734   r = guestfs_stat (g, path);
1735   if (r == NULL)
1736     rb_raise (e_Error, "%s", guestfs_last_error (g));
1737
1738   VALUE rv = rb_hash_new ();
1739   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1740   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1741   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1742   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1743   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1744   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1745   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1746   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1747   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1748   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1749   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1750   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1751   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1752   free (r);
1753   return rv;
1754 }
1755
1756 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
1757 {
1758   guestfs_h *g;
1759   Data_Get_Struct (gv, guestfs_h, g);
1760   if (!g)
1761     rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
1762
1763   const char *path = StringValueCStr (pathv);
1764   if (!path)
1765     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1766               "path", "lstat");
1767
1768   struct guestfs_stat *r;
1769
1770   r = guestfs_lstat (g, path);
1771   if (r == NULL)
1772     rb_raise (e_Error, "%s", guestfs_last_error (g));
1773
1774   VALUE rv = rb_hash_new ();
1775   rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1776   rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1777   rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1778   rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1779   rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1780   rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1781   rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1782   rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1783   rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1784   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1785   rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1786   rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1787   rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1788   free (r);
1789   return rv;
1790 }
1791
1792 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
1793 {
1794   guestfs_h *g;
1795   Data_Get_Struct (gv, guestfs_h, g);
1796   if (!g)
1797     rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
1798
1799   const char *path = StringValueCStr (pathv);
1800   if (!path)
1801     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1802               "path", "statvfs");
1803
1804   struct guestfs_statvfs *r;
1805
1806   r = guestfs_statvfs (g, path);
1807   if (r == NULL)
1808     rb_raise (e_Error, "%s", guestfs_last_error (g));
1809
1810   VALUE rv = rb_hash_new ();
1811   rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
1812   rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
1813   rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1814   rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
1815   rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
1816   rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
1817   rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
1818   rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
1819   rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
1820   rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
1821   rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
1822   free (r);
1823   return rv;
1824 }
1825
1826 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
1827 {
1828   guestfs_h *g;
1829   Data_Get_Struct (gv, guestfs_h, g);
1830   if (!g)
1831     rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
1832
1833   const char *device = StringValueCStr (devicev);
1834   if (!device)
1835     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1836               "device", "tune2fs_l");
1837
1838   char **r;
1839
1840   r = guestfs_tune2fs_l (g, device);
1841   if (r == NULL)
1842     rb_raise (e_Error, "%s", guestfs_last_error (g));
1843
1844   VALUE rv = rb_hash_new ();
1845   int i;
1846   for (i = 0; r[i] != NULL; i+=2) {
1847     rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
1848     free (r[i]);
1849     free (r[i+1]);
1850   }
1851   free (r);
1852   return rv;
1853 }
1854
1855 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
1856 {
1857   guestfs_h *g;
1858   Data_Get_Struct (gv, guestfs_h, g);
1859   if (!g)
1860     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
1861
1862   const char *device = StringValueCStr (devicev);
1863   if (!device)
1864     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1865               "device", "blockdev_setro");
1866
1867   int r;
1868
1869   r = guestfs_blockdev_setro (g, device);
1870   if (r == -1)
1871     rb_raise (e_Error, "%s", guestfs_last_error (g));
1872
1873   return Qnil;
1874 }
1875
1876 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
1877 {
1878   guestfs_h *g;
1879   Data_Get_Struct (gv, guestfs_h, g);
1880   if (!g)
1881     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
1882
1883   const char *device = StringValueCStr (devicev);
1884   if (!device)
1885     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1886               "device", "blockdev_setrw");
1887
1888   int r;
1889
1890   r = guestfs_blockdev_setrw (g, device);
1891   if (r == -1)
1892     rb_raise (e_Error, "%s", guestfs_last_error (g));
1893
1894   return Qnil;
1895 }
1896
1897 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
1898 {
1899   guestfs_h *g;
1900   Data_Get_Struct (gv, guestfs_h, g);
1901   if (!g)
1902     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
1903
1904   const char *device = StringValueCStr (devicev);
1905   if (!device)
1906     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1907               "device", "blockdev_getro");
1908
1909   int r;
1910
1911   r = guestfs_blockdev_getro (g, device);
1912   if (r == -1)
1913     rb_raise (e_Error, "%s", guestfs_last_error (g));
1914
1915   return INT2NUM (r);
1916 }
1917
1918 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
1919 {
1920   guestfs_h *g;
1921   Data_Get_Struct (gv, guestfs_h, g);
1922   if (!g)
1923     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
1924
1925   const char *device = StringValueCStr (devicev);
1926   if (!device)
1927     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1928               "device", "blockdev_getss");
1929
1930   int r;
1931
1932   r = guestfs_blockdev_getss (g, device);
1933   if (r == -1)
1934     rb_raise (e_Error, "%s", guestfs_last_error (g));
1935
1936   return INT2NUM (r);
1937 }
1938
1939 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
1940 {
1941   guestfs_h *g;
1942   Data_Get_Struct (gv, guestfs_h, g);
1943   if (!g)
1944     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
1945
1946   const char *device = StringValueCStr (devicev);
1947   if (!device)
1948     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1949               "device", "blockdev_getbsz");
1950
1951   int r;
1952
1953   r = guestfs_blockdev_getbsz (g, device);
1954   if (r == -1)
1955     rb_raise (e_Error, "%s", guestfs_last_error (g));
1956
1957   return INT2NUM (r);
1958 }
1959
1960 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
1961 {
1962   guestfs_h *g;
1963   Data_Get_Struct (gv, guestfs_h, g);
1964   if (!g)
1965     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
1966
1967   const char *device = StringValueCStr (devicev);
1968   if (!device)
1969     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1970               "device", "blockdev_setbsz");
1971   int blocksize = NUM2INT (blocksizev);
1972
1973   int r;
1974
1975   r = guestfs_blockdev_setbsz (g, device, blocksize);
1976   if (r == -1)
1977     rb_raise (e_Error, "%s", guestfs_last_error (g));
1978
1979   return Qnil;
1980 }
1981
1982 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
1983 {
1984   guestfs_h *g;
1985   Data_Get_Struct (gv, guestfs_h, g);
1986   if (!g)
1987     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
1988
1989   const char *device = StringValueCStr (devicev);
1990   if (!device)
1991     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1992               "device", "blockdev_getsz");
1993
1994   int64_t r;
1995
1996   r = guestfs_blockdev_getsz (g, device);
1997   if (r == -1)
1998     rb_raise (e_Error, "%s", guestfs_last_error (g));
1999
2000   return ULL2NUM (r);
2001 }
2002
2003 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2004 {
2005   guestfs_h *g;
2006   Data_Get_Struct (gv, guestfs_h, g);
2007   if (!g)
2008     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2009
2010   const char *device = StringValueCStr (devicev);
2011   if (!device)
2012     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2013               "device", "blockdev_getsize64");
2014
2015   int64_t r;
2016
2017   r = guestfs_blockdev_getsize64 (g, device);
2018   if (r == -1)
2019     rb_raise (e_Error, "%s", guestfs_last_error (g));
2020
2021   return ULL2NUM (r);
2022 }
2023
2024 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2025 {
2026   guestfs_h *g;
2027   Data_Get_Struct (gv, guestfs_h, g);
2028   if (!g)
2029     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2030
2031   const char *device = StringValueCStr (devicev);
2032   if (!device)
2033     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2034               "device", "blockdev_flushbufs");
2035
2036   int r;
2037
2038   r = guestfs_blockdev_flushbufs (g, device);
2039   if (r == -1)
2040     rb_raise (e_Error, "%s", guestfs_last_error (g));
2041
2042   return Qnil;
2043 }
2044
2045 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2046 {
2047   guestfs_h *g;
2048   Data_Get_Struct (gv, guestfs_h, g);
2049   if (!g)
2050     rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2051
2052   const char *device = StringValueCStr (devicev);
2053   if (!device)
2054     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2055               "device", "blockdev_rereadpt");
2056
2057   int r;
2058
2059   r = guestfs_blockdev_rereadpt (g, device);
2060   if (r == -1)
2061     rb_raise (e_Error, "%s", guestfs_last_error (g));
2062
2063   return Qnil;
2064 }
2065
2066 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2067 {
2068   guestfs_h *g;
2069   Data_Get_Struct (gv, guestfs_h, g);
2070   if (!g)
2071     rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2072
2073   const char *filename = StringValueCStr (filenamev);
2074   if (!filename)
2075     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2076               "filename", "upload");
2077   const char *remotefilename = StringValueCStr (remotefilenamev);
2078   if (!remotefilename)
2079     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2080               "remotefilename", "upload");
2081
2082   int r;
2083
2084   r = guestfs_upload (g, filename, remotefilename);
2085   if (r == -1)
2086     rb_raise (e_Error, "%s", guestfs_last_error (g));
2087
2088   return Qnil;
2089 }
2090
2091 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2092 {
2093   guestfs_h *g;
2094   Data_Get_Struct (gv, guestfs_h, g);
2095   if (!g)
2096     rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2097
2098   const char *remotefilename = StringValueCStr (remotefilenamev);
2099   if (!remotefilename)
2100     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2101               "remotefilename", "download");
2102   const char *filename = StringValueCStr (filenamev);
2103   if (!filename)
2104     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2105               "filename", "download");
2106
2107   int r;
2108
2109   r = guestfs_download (g, remotefilename, filename);
2110   if (r == -1)
2111     rb_raise (e_Error, "%s", guestfs_last_error (g));
2112
2113   return Qnil;
2114 }
2115
2116 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2117 {
2118   guestfs_h *g;
2119   Data_Get_Struct (gv, guestfs_h, g);
2120   if (!g)
2121     rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2122
2123   const char *csumtype = StringValueCStr (csumtypev);
2124   if (!csumtype)
2125     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2126               "csumtype", "checksum");
2127   const char *path = StringValueCStr (pathv);
2128   if (!path)
2129     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2130               "path", "checksum");
2131
2132   char *r;
2133
2134   r = guestfs_checksum (g, csumtype, path);
2135   if (r == NULL)
2136     rb_raise (e_Error, "%s", guestfs_last_error (g));
2137
2138   VALUE rv = rb_str_new2 (r);
2139   free (r);
2140   return rv;
2141 }
2142
2143 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2144 {
2145   guestfs_h *g;
2146   Data_Get_Struct (gv, guestfs_h, g);
2147   if (!g)
2148     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
2149
2150   const char *tarfile = StringValueCStr (tarfilev);
2151   if (!tarfile)
2152     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2153               "tarfile", "tar_in");
2154   const char *directory = StringValueCStr (directoryv);
2155   if (!directory)
2156     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2157               "directory", "tar_in");
2158
2159   int r;
2160
2161   r = guestfs_tar_in (g, tarfile, directory);
2162   if (r == -1)
2163     rb_raise (e_Error, "%s", guestfs_last_error (g));
2164
2165   return Qnil;
2166 }
2167
2168 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
2169 {
2170   guestfs_h *g;
2171   Data_Get_Struct (gv, guestfs_h, g);
2172   if (!g)
2173     rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
2174
2175   const char *directory = StringValueCStr (directoryv);
2176   if (!directory)
2177     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2178               "directory", "tar_out");
2179   const char *tarfile = StringValueCStr (tarfilev);
2180   if (!tarfile)
2181     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2182               "tarfile", "tar_out");
2183
2184   int r;
2185
2186   r = guestfs_tar_out (g, directory, tarfile);
2187   if (r == -1)
2188     rb_raise (e_Error, "%s", guestfs_last_error (g));
2189
2190   return Qnil;
2191 }
2192
2193 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
2194 {
2195   guestfs_h *g;
2196   Data_Get_Struct (gv, guestfs_h, g);
2197   if (!g)
2198     rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
2199
2200   const char *tarball = StringValueCStr (tarballv);
2201   if (!tarball)
2202     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2203               "tarball", "tgz_in");
2204   const char *directory = StringValueCStr (directoryv);
2205   if (!directory)
2206     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2207               "directory", "tgz_in");
2208
2209   int r;
2210
2211   r = guestfs_tgz_in (g, tarball, directory);
2212   if (r == -1)
2213     rb_raise (e_Error, "%s", guestfs_last_error (g));
2214
2215   return Qnil;
2216 }
2217
2218 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
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", "tgz_out");
2224
2225   const char *directory = StringValueCStr (directoryv);
2226   if (!directory)
2227     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2228               "directory", "tgz_out");
2229   const char *tarball = StringValueCStr (tarballv);
2230   if (!tarball)
2231     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2232               "tarball", "tgz_out");
2233
2234   int r;
2235
2236   r = guestfs_tgz_out (g, directory, tarball);
2237   if (r == -1)
2238     rb_raise (e_Error, "%s", guestfs_last_error (g));
2239
2240   return Qnil;
2241 }
2242
2243 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
2244 {
2245   guestfs_h *g;
2246   Data_Get_Struct (gv, guestfs_h, g);
2247   if (!g)
2248     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
2249
2250   const char *device = StringValueCStr (devicev);
2251   if (!device)
2252     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2253               "device", "mount_ro");
2254   const char *mountpoint = StringValueCStr (mountpointv);
2255   if (!mountpoint)
2256     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2257               "mountpoint", "mount_ro");
2258
2259   int r;
2260
2261   r = guestfs_mount_ro (g, device, mountpoint);
2262   if (r == -1)
2263     rb_raise (e_Error, "%s", guestfs_last_error (g));
2264
2265   return Qnil;
2266 }
2267
2268 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
2269 {
2270   guestfs_h *g;
2271   Data_Get_Struct (gv, guestfs_h, g);
2272   if (!g)
2273     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
2274
2275   const char *options = StringValueCStr (optionsv);
2276   if (!options)
2277     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2278               "options", "mount_options");
2279   const char *device = StringValueCStr (devicev);
2280   if (!device)
2281     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2282               "device", "mount_options");
2283   const char *mountpoint = StringValueCStr (mountpointv);
2284   if (!mountpoint)
2285     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2286               "mountpoint", "mount_options");
2287
2288   int r;
2289
2290   r = guestfs_mount_options (g, options, device, mountpoint);
2291   if (r == -1)
2292     rb_raise (e_Error, "%s", guestfs_last_error (g));
2293
2294   return Qnil;
2295 }
2296
2297 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
2298 {
2299   guestfs_h *g;
2300   Data_Get_Struct (gv, guestfs_h, g);
2301   if (!g)
2302     rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
2303
2304   const char *options = StringValueCStr (optionsv);
2305   if (!options)
2306     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2307               "options", "mount_vfs");
2308   const char *vfstype = StringValueCStr (vfstypev);
2309   if (!vfstype)
2310     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2311               "vfstype", "mount_vfs");
2312   const char *device = StringValueCStr (devicev);
2313   if (!device)
2314     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2315               "device", "mount_vfs");
2316   const char *mountpoint = StringValueCStr (mountpointv);
2317   if (!mountpoint)
2318     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2319               "mountpoint", "mount_vfs");
2320
2321   int r;
2322
2323   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2324   if (r == -1)
2325     rb_raise (e_Error, "%s", guestfs_last_error (g));
2326
2327   return Qnil;
2328 }
2329
2330 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
2331 {
2332   guestfs_h *g;
2333   Data_Get_Struct (gv, guestfs_h, g);
2334   if (!g)
2335     rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
2336
2337   const char *subcmd = StringValueCStr (subcmdv);
2338   if (!subcmd)
2339     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2340               "subcmd", "debug");
2341   char **extraargs;  {
2342     int i, len;
2343     len = RARRAY_LEN (extraargsv);
2344     extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2345     for (i = 0; i < len; ++i) {
2346       VALUE v = rb_ary_entry (extraargsv, i);
2347       extraargs[i] = StringValueCStr (v);
2348     }
2349     extraargs[len] = NULL;
2350   }
2351
2352   char *r;
2353
2354   r = guestfs_debug (g, subcmd, extraargs);
2355   free (extraargs);
2356   if (r == NULL)
2357     rb_raise (e_Error, "%s", guestfs_last_error (g));
2358
2359   VALUE rv = rb_str_new2 (r);
2360   free (r);
2361   return rv;
2362 }
2363
2364 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
2365 {
2366   guestfs_h *g;
2367   Data_Get_Struct (gv, guestfs_h, g);
2368   if (!g)
2369     rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
2370
2371   const char *device = StringValueCStr (devicev);
2372   if (!device)
2373     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2374               "device", "lvremove");
2375
2376   int r;
2377
2378   r = guestfs_lvremove (g, device);
2379   if (r == -1)
2380     rb_raise (e_Error, "%s", guestfs_last_error (g));
2381
2382   return Qnil;
2383 }
2384
2385 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
2386 {
2387   guestfs_h *g;
2388   Data_Get_Struct (gv, guestfs_h, g);
2389   if (!g)
2390     rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
2391
2392   const char *vgname = StringValueCStr (vgnamev);
2393   if (!vgname)
2394     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2395               "vgname", "vgremove");
2396
2397   int r;
2398
2399   r = guestfs_vgremove (g, vgname);
2400   if (r == -1)
2401     rb_raise (e_Error, "%s", guestfs_last_error (g));
2402
2403   return Qnil;
2404 }
2405
2406 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
2407 {
2408   guestfs_h *g;
2409   Data_Get_Struct (gv, guestfs_h, g);
2410   if (!g)
2411     rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
2412
2413   const char *device = StringValueCStr (devicev);
2414   if (!device)
2415     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2416               "device", "pvremove");
2417
2418   int r;
2419
2420   r = guestfs_pvremove (g, device);
2421   if (r == -1)
2422     rb_raise (e_Error, "%s", guestfs_last_error (g));
2423
2424   return Qnil;
2425 }
2426
2427 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
2428 {
2429   guestfs_h *g;
2430   Data_Get_Struct (gv, guestfs_h, g);
2431   if (!g)
2432     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
2433
2434   const char *device = StringValueCStr (devicev);
2435   if (!device)
2436     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2437               "device", "set_e2label");
2438   const char *label = StringValueCStr (labelv);
2439   if (!label)
2440     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2441               "label", "set_e2label");
2442
2443   int r;
2444
2445   r = guestfs_set_e2label (g, device, label);
2446   if (r == -1)
2447     rb_raise (e_Error, "%s", guestfs_last_error (g));
2448
2449   return Qnil;
2450 }
2451
2452 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
2453 {
2454   guestfs_h *g;
2455   Data_Get_Struct (gv, guestfs_h, g);
2456   if (!g)
2457     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
2458
2459   const char *device = StringValueCStr (devicev);
2460   if (!device)
2461     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2462               "device", "get_e2label");
2463
2464   char *r;
2465
2466   r = guestfs_get_e2label (g, device);
2467   if (r == NULL)
2468     rb_raise (e_Error, "%s", guestfs_last_error (g));
2469
2470   VALUE rv = rb_str_new2 (r);
2471   free (r);
2472   return rv;
2473 }
2474
2475 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
2476 {
2477   guestfs_h *g;
2478   Data_Get_Struct (gv, guestfs_h, g);
2479   if (!g)
2480     rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
2481
2482   const char *device = StringValueCStr (devicev);
2483   if (!device)
2484     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2485               "device", "set_e2uuid");
2486   const char *uuid = StringValueCStr (uuidv);
2487   if (!uuid)
2488     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2489               "uuid", "set_e2uuid");
2490
2491   int r;
2492
2493   r = guestfs_set_e2uuid (g, device, uuid);
2494   if (r == -1)
2495     rb_raise (e_Error, "%s", guestfs_last_error (g));
2496
2497   return Qnil;
2498 }
2499
2500 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
2501 {
2502   guestfs_h *g;
2503   Data_Get_Struct (gv, guestfs_h, g);
2504   if (!g)
2505     rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
2506
2507   const char *device = StringValueCStr (devicev);
2508   if (!device)
2509     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2510               "device", "get_e2uuid");
2511
2512   char *r;
2513
2514   r = guestfs_get_e2uuid (g, device);
2515   if (r == NULL)
2516     rb_raise (e_Error, "%s", guestfs_last_error (g));
2517
2518   VALUE rv = rb_str_new2 (r);
2519   free (r);
2520   return rv;
2521 }
2522
2523 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
2524 {
2525   guestfs_h *g;
2526   Data_Get_Struct (gv, guestfs_h, g);
2527   if (!g)
2528     rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
2529
2530   const char *fstype = StringValueCStr (fstypev);
2531   if (!fstype)
2532     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2533               "fstype", "fsck");
2534   const char *device = StringValueCStr (devicev);
2535   if (!device)
2536     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2537               "device", "fsck");
2538
2539   int r;
2540
2541   r = guestfs_fsck (g, fstype, device);
2542   if (r == -1)
2543     rb_raise (e_Error, "%s", guestfs_last_error (g));
2544
2545   return INT2NUM (r);
2546 }
2547
2548 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
2549 {
2550   guestfs_h *g;
2551   Data_Get_Struct (gv, guestfs_h, g);
2552   if (!g)
2553     rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
2554
2555   const char *device = StringValueCStr (devicev);
2556   if (!device)
2557     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2558               "device", "zero");
2559
2560   int r;
2561
2562   r = guestfs_zero (g, device);
2563   if (r == -1)
2564     rb_raise (e_Error, "%s", guestfs_last_error (g));
2565
2566   return Qnil;
2567 }
2568
2569 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
2570 {
2571   guestfs_h *g;
2572   Data_Get_Struct (gv, guestfs_h, g);
2573   if (!g)
2574     rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
2575
2576   const char *root = StringValueCStr (rootv);
2577   if (!root)
2578     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2579               "root", "grub_install");
2580   const char *device = StringValueCStr (devicev);
2581   if (!device)
2582     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2583               "device", "grub_install");
2584
2585   int r;
2586
2587   r = guestfs_grub_install (g, root, device);
2588   if (r == -1)
2589     rb_raise (e_Error, "%s", guestfs_last_error (g));
2590
2591   return Qnil;
2592 }
2593
2594 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
2595 {
2596   guestfs_h *g;
2597   Data_Get_Struct (gv, guestfs_h, g);
2598   if (!g)
2599     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
2600
2601   const char *src = StringValueCStr (srcv);
2602   if (!src)
2603     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2604               "src", "cp");
2605   const char *dest = StringValueCStr (destv);
2606   if (!dest)
2607     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2608               "dest", "cp");
2609
2610   int r;
2611
2612   r = guestfs_cp (g, src, dest);
2613   if (r == -1)
2614     rb_raise (e_Error, "%s", guestfs_last_error (g));
2615
2616   return Qnil;
2617 }
2618
2619 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
2620 {
2621   guestfs_h *g;
2622   Data_Get_Struct (gv, guestfs_h, g);
2623   if (!g)
2624     rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
2625
2626   const char *src = StringValueCStr (srcv);
2627   if (!src)
2628     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2629               "src", "cp_a");
2630   const char *dest = StringValueCStr (destv);
2631   if (!dest)
2632     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2633               "dest", "cp_a");
2634
2635   int r;
2636
2637   r = guestfs_cp_a (g, src, dest);
2638   if (r == -1)
2639     rb_raise (e_Error, "%s", guestfs_last_error (g));
2640
2641   return Qnil;
2642 }
2643
2644 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
2645 {
2646   guestfs_h *g;
2647   Data_Get_Struct (gv, guestfs_h, g);
2648   if (!g)
2649     rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
2650
2651   const char *src = StringValueCStr (srcv);
2652   if (!src)
2653     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2654               "src", "mv");
2655   const char *dest = StringValueCStr (destv);
2656   if (!dest)
2657     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2658               "dest", "mv");
2659
2660   int r;
2661
2662   r = guestfs_mv (g, src, dest);
2663   if (r == -1)
2664     rb_raise (e_Error, "%s", guestfs_last_error (g));
2665
2666   return Qnil;
2667 }
2668
2669 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
2670 {
2671   guestfs_h *g;
2672   Data_Get_Struct (gv, guestfs_h, g);
2673   if (!g)
2674     rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
2675
2676   int whattodrop = NUM2INT (whattodropv);
2677
2678   int r;
2679
2680   r = guestfs_drop_caches (g, whattodrop);
2681   if (r == -1)
2682     rb_raise (e_Error, "%s", guestfs_last_error (g));
2683
2684   return Qnil;
2685 }
2686
2687 static VALUE ruby_guestfs_dmesg (VALUE gv)
2688 {
2689   guestfs_h *g;
2690   Data_Get_Struct (gv, guestfs_h, g);
2691   if (!g)
2692     rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
2693
2694
2695   char *r;
2696
2697   r = guestfs_dmesg (g);
2698   if (r == NULL)
2699     rb_raise (e_Error, "%s", guestfs_last_error (g));
2700
2701   VALUE rv = rb_str_new2 (r);
2702   free (r);
2703   return rv;
2704 }
2705
2706 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
2707 {
2708   guestfs_h *g;
2709   Data_Get_Struct (gv, guestfs_h, g);
2710   if (!g)
2711     rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
2712
2713
2714   int r;
2715
2716   r = guestfs_ping_daemon (g);
2717   if (r == -1)
2718     rb_raise (e_Error, "%s", guestfs_last_error (g));
2719
2720   return Qnil;
2721 }
2722
2723 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
2724 {
2725   guestfs_h *g;
2726   Data_Get_Struct (gv, guestfs_h, g);
2727   if (!g)
2728     rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
2729
2730   const char *file1 = StringValueCStr (file1v);
2731   if (!file1)
2732     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2733               "file1", "equal");
2734   const char *file2 = StringValueCStr (file2v);
2735   if (!file2)
2736     rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2737               "file2", "equal");
2738
2739   int r;
2740
2741   r = guestfs_equal (g, file1, file2);
2742   if (r == -1)
2743     rb_raise (e_Error, "%s", guestfs_last_error (g));
2744
2745   return INT2NUM (r);
2746 }
2747
2748 /* Initialize the module. */
2749 void Init__guestfs ()
2750 {
2751   m_guestfs = rb_define_module ("Guestfs");
2752   c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
2753   e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
2754
2755   rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
2756   rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
2757
2758   rb_define_method (c_guestfs, "launch",
2759         ruby_guestfs_launch, 0);
2760   rb_define_method (c_guestfs, "wait_ready",
2761         ruby_guestfs_wait_ready, 0);
2762   rb_define_method (c_guestfs, "kill_subprocess",
2763         ruby_guestfs_kill_subprocess, 0);
2764   rb_define_method (c_guestfs, "add_drive",
2765         ruby_guestfs_add_drive, 1);
2766   rb_define_method (c_guestfs, "add_cdrom",
2767         ruby_guestfs_add_cdrom, 1);
2768   rb_define_method (c_guestfs, "config",
2769         ruby_guestfs_config, 2);
2770   rb_define_method (c_guestfs, "set_qemu",
2771         ruby_guestfs_set_qemu, 1);
2772   rb_define_method (c_guestfs, "get_qemu",
2773         ruby_guestfs_get_qemu, 0);
2774   rb_define_method (c_guestfs, "set_path",
2775         ruby_guestfs_set_path, 1);
2776   rb_define_method (c_guestfs, "get_path",
2777         ruby_guestfs_get_path, 0);
2778   rb_define_method (c_guestfs, "set_autosync",
2779         ruby_guestfs_set_autosync, 1);
2780   rb_define_method (c_guestfs, "get_autosync",
2781         ruby_guestfs_get_autosync, 0);
2782   rb_define_method (c_guestfs, "set_verbose",
2783         ruby_guestfs_set_verbose, 1);
2784   rb_define_method (c_guestfs, "get_verbose",
2785         ruby_guestfs_get_verbose, 0);
2786   rb_define_method (c_guestfs, "is_ready",
2787         ruby_guestfs_is_ready, 0);
2788   rb_define_method (c_guestfs, "is_config",
2789         ruby_guestfs_is_config, 0);
2790   rb_define_method (c_guestfs, "is_launching",
2791         ruby_guestfs_is_launching, 0);
2792   rb_define_method (c_guestfs, "is_busy",
2793         ruby_guestfs_is_busy, 0);
2794   rb_define_method (c_guestfs, "get_state",
2795         ruby_guestfs_get_state, 0);
2796   rb_define_method (c_guestfs, "set_busy",
2797         ruby_guestfs_set_busy, 0);
2798   rb_define_method (c_guestfs, "set_ready",
2799         ruby_guestfs_set_ready, 0);
2800   rb_define_method (c_guestfs, "mount",
2801         ruby_guestfs_mount, 2);
2802   rb_define_method (c_guestfs, "sync",
2803         ruby_guestfs_sync, 0);
2804   rb_define_method (c_guestfs, "touch",
2805         ruby_guestfs_touch, 1);
2806   rb_define_method (c_guestfs, "cat",
2807         ruby_guestfs_cat, 1);
2808   rb_define_method (c_guestfs, "ll",
2809         ruby_guestfs_ll, 1);
2810   rb_define_method (c_guestfs, "ls",
2811         ruby_guestfs_ls, 1);
2812   rb_define_method (c_guestfs, "list_devices",
2813         ruby_guestfs_list_devices, 0);
2814   rb_define_method (c_guestfs, "list_partitions",
2815         ruby_guestfs_list_partitions, 0);
2816   rb_define_method (c_guestfs, "pvs",
2817         ruby_guestfs_pvs, 0);
2818   rb_define_method (c_guestfs, "vgs",
2819         ruby_guestfs_vgs, 0);
2820   rb_define_method (c_guestfs, "lvs",
2821         ruby_guestfs_lvs, 0);
2822   rb_define_method (c_guestfs, "pvs_full",
2823         ruby_guestfs_pvs_full, 0);
2824   rb_define_method (c_guestfs, "vgs_full",
2825         ruby_guestfs_vgs_full, 0);
2826   rb_define_method (c_guestfs, "lvs_full",
2827         ruby_guestfs_lvs_full, 0);
2828   rb_define_method (c_guestfs, "read_lines",
2829         ruby_guestfs_read_lines, 1);
2830   rb_define_method (c_guestfs, "aug_init",
2831         ruby_guestfs_aug_init, 2);
2832   rb_define_method (c_guestfs, "aug_close",
2833         ruby_guestfs_aug_close, 0);
2834   rb_define_method (c_guestfs, "aug_defvar",
2835         ruby_guestfs_aug_defvar, 2);
2836   rb_define_method (c_guestfs, "aug_defnode",
2837         ruby_guestfs_aug_defnode, 3);
2838   rb_define_method (c_guestfs, "aug_get",
2839         ruby_guestfs_aug_get, 1);
2840   rb_define_method (c_guestfs, "aug_set",
2841         ruby_guestfs_aug_set, 2);
2842   rb_define_method (c_guestfs, "aug_insert",
2843         ruby_guestfs_aug_insert, 3);
2844   rb_define_method (c_guestfs, "aug_rm",
2845         ruby_guestfs_aug_rm, 1);
2846   rb_define_method (c_guestfs, "aug_mv",
2847         ruby_guestfs_aug_mv, 2);
2848   rb_define_method (c_guestfs, "aug_match",
2849         ruby_guestfs_aug_match, 1);
2850   rb_define_method (c_guestfs, "aug_save",
2851         ruby_guestfs_aug_save, 0);
2852   rb_define_method (c_guestfs, "aug_load",
2853         ruby_guestfs_aug_load, 0);
2854   rb_define_method (c_guestfs, "aug_ls",
2855         ruby_guestfs_aug_ls, 1);
2856   rb_define_method (c_guestfs, "rm",
2857         ruby_guestfs_rm, 1);
2858   rb_define_method (c_guestfs, "rmdir",
2859         ruby_guestfs_rmdir, 1);
2860   rb_define_method (c_guestfs, "rm_rf",
2861         ruby_guestfs_rm_rf, 1);
2862   rb_define_method (c_guestfs, "mkdir",
2863         ruby_guestfs_mkdir, 1);
2864   rb_define_method (c_guestfs, "mkdir_p",
2865         ruby_guestfs_mkdir_p, 1);
2866   rb_define_method (c_guestfs, "chmod",
2867         ruby_guestfs_chmod, 2);
2868   rb_define_method (c_guestfs, "chown",
2869         ruby_guestfs_chown, 3);
2870   rb_define_method (c_guestfs, "exists",
2871         ruby_guestfs_exists, 1);
2872   rb_define_method (c_guestfs, "is_file",
2873         ruby_guestfs_is_file, 1);
2874   rb_define_method (c_guestfs, "is_dir",
2875         ruby_guestfs_is_dir, 1);
2876   rb_define_method (c_guestfs, "pvcreate",
2877         ruby_guestfs_pvcreate, 1);
2878   rb_define_method (c_guestfs, "vgcreate",
2879         ruby_guestfs_vgcreate, 2);
2880   rb_define_method (c_guestfs, "lvcreate",
2881         ruby_guestfs_lvcreate, 3);
2882   rb_define_method (c_guestfs, "mkfs",
2883         ruby_guestfs_mkfs, 2);
2884   rb_define_method (c_guestfs, "sfdisk",
2885         ruby_guestfs_sfdisk, 5);
2886   rb_define_method (c_guestfs, "write_file",
2887         ruby_guestfs_write_file, 3);
2888   rb_define_method (c_guestfs, "umount",
2889         ruby_guestfs_umount, 1);
2890   rb_define_method (c_guestfs, "mounts",
2891         ruby_guestfs_mounts, 0);
2892   rb_define_method (c_guestfs, "umount_all",
2893         ruby_guestfs_umount_all, 0);
2894   rb_define_method (c_guestfs, "lvm_remove_all",
2895         ruby_guestfs_lvm_remove_all, 0);
2896   rb_define_method (c_guestfs, "file",
2897         ruby_guestfs_file, 1);
2898   rb_define_method (c_guestfs, "command",
2899         ruby_guestfs_command, 1);
2900   rb_define_method (c_guestfs, "command_lines",
2901         ruby_guestfs_command_lines, 1);
2902   rb_define_method (c_guestfs, "stat",
2903         ruby_guestfs_stat, 1);
2904   rb_define_method (c_guestfs, "lstat",
2905         ruby_guestfs_lstat, 1);
2906   rb_define_method (c_guestfs, "statvfs",
2907         ruby_guestfs_statvfs, 1);
2908   rb_define_method (c_guestfs, "tune2fs_l",
2909         ruby_guestfs_tune2fs_l, 1);
2910   rb_define_method (c_guestfs, "blockdev_setro",
2911         ruby_guestfs_blockdev_setro, 1);
2912   rb_define_method (c_guestfs, "blockdev_setrw",
2913         ruby_guestfs_blockdev_setrw, 1);
2914   rb_define_method (c_guestfs, "blockdev_getro",
2915         ruby_guestfs_blockdev_getro, 1);
2916   rb_define_method (c_guestfs, "blockdev_getss",
2917         ruby_guestfs_blockdev_getss, 1);
2918   rb_define_method (c_guestfs, "blockdev_getbsz",
2919         ruby_guestfs_blockdev_getbsz, 1);
2920   rb_define_method (c_guestfs, "blockdev_setbsz",
2921         ruby_guestfs_blockdev_setbsz, 2);
2922   rb_define_method (c_guestfs, "blockdev_getsz",
2923         ruby_guestfs_blockdev_getsz, 1);
2924   rb_define_method (c_guestfs, "blockdev_getsize64",
2925         ruby_guestfs_blockdev_getsize64, 1);
2926   rb_define_method (c_guestfs, "blockdev_flushbufs",
2927         ruby_guestfs_blockdev_flushbufs, 1);
2928   rb_define_method (c_guestfs, "blockdev_rereadpt",
2929         ruby_guestfs_blockdev_rereadpt, 1);
2930   rb_define_method (c_guestfs, "upload",
2931         ruby_guestfs_upload, 2);
2932   rb_define_method (c_guestfs, "download",
2933         ruby_guestfs_download, 2);
2934   rb_define_method (c_guestfs, "checksum",
2935         ruby_guestfs_checksum, 2);
2936   rb_define_method (c_guestfs, "tar_in",
2937         ruby_guestfs_tar_in, 2);
2938   rb_define_method (c_guestfs, "tar_out",
2939         ruby_guestfs_tar_out, 2);
2940   rb_define_method (c_guestfs, "tgz_in",
2941         ruby_guestfs_tgz_in, 2);
2942   rb_define_method (c_guestfs, "tgz_out",
2943         ruby_guestfs_tgz_out, 2);
2944   rb_define_method (c_guestfs, "mount_ro",
2945         ruby_guestfs_mount_ro, 2);
2946   rb_define_method (c_guestfs, "mount_options",
2947         ruby_guestfs_mount_options, 3);
2948   rb_define_method (c_guestfs, "mount_vfs",
2949         ruby_guestfs_mount_vfs, 4);
2950   rb_define_method (c_guestfs, "debug",
2951         ruby_guestfs_debug, 2);
2952   rb_define_method (c_guestfs, "lvremove",
2953         ruby_guestfs_lvremove, 1);
2954   rb_define_method (c_guestfs, "vgremove",
2955         ruby_guestfs_vgremove, 1);
2956   rb_define_method (c_guestfs, "pvremove",
2957         ruby_guestfs_pvremove, 1);
2958   rb_define_method (c_guestfs, "set_e2label",
2959         ruby_guestfs_set_e2label, 2);
2960   rb_define_method (c_guestfs, "get_e2label",
2961         ruby_guestfs_get_e2label, 1);
2962   rb_define_method (c_guestfs, "set_e2uuid",
2963         ruby_guestfs_set_e2uuid, 2);
2964   rb_define_method (c_guestfs, "get_e2uuid",
2965         ruby_guestfs_get_e2uuid, 1);
2966   rb_define_method (c_guestfs, "fsck",
2967         ruby_guestfs_fsck, 2);
2968   rb_define_method (c_guestfs, "zero",
2969         ruby_guestfs_zero, 1);
2970   rb_define_method (c_guestfs, "grub_install",
2971         ruby_guestfs_grub_install, 2);
2972   rb_define_method (c_guestfs, "cp",
2973         ruby_guestfs_cp, 2);
2974   rb_define_method (c_guestfs, "cp_a",
2975         ruby_guestfs_cp_a, 2);
2976   rb_define_method (c_guestfs, "mv",
2977         ruby_guestfs_mv, 2);
2978   rb_define_method (c_guestfs, "drop_caches",
2979         ruby_guestfs_drop_caches, 1);
2980   rb_define_method (c_guestfs, "dmesg",
2981         ruby_guestfs_dmesg, 0);
2982   rb_define_method (c_guestfs, "ping_daemon",
2983         ruby_guestfs_ping_daemon, 0);
2984   rb_define_method (c_guestfs, "equal",
2985         ruby_guestfs_equal, 2);
2986 }