ruby/ext/guestfs/_guestfs.c

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