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.
5 * Copyright (C) 2009 Red Hat Inc.
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.
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.
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
33 #define RARRAY_LEN(r) (RARRAY((r))->len)
36 static VALUE m_guestfs; /* guestfs module */
37 static VALUE c_guestfs; /* guestfs_h handle */
38 static VALUE e_Error; /* used for all errors */
40 static void ruby_guestfs_free (void *p)
43 guestfs_close ((guestfs_h *) p);
46 static VALUE ruby_guestfs_create (VALUE m)
50 g = guestfs_create ();
52 rb_raise (e_Error, "failed to create guestfs handle");
54 /* Don't print error messages to stderr by default. */
55 guestfs_set_error_handler (g, NULL, NULL);
57 /* Wrap it, and make sure the close function is called when the
60 return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
63 static VALUE ruby_guestfs_close (VALUE gv)
66 Data_Get_Struct (gv, guestfs_h, g);
68 ruby_guestfs_free (g);
74 static VALUE ruby_guestfs_launch (VALUE gv)
77 Data_Get_Struct (gv, guestfs_h, g);
79 rb_raise (rb_eArgError, "%s: used handle after closing it", "launch");
84 r = guestfs_launch (g);
86 rb_raise (e_Error, "%s", guestfs_last_error (g));
91 static VALUE ruby_guestfs_wait_ready (VALUE gv)
94 Data_Get_Struct (gv, guestfs_h, g);
96 rb_raise (rb_eArgError, "%s: used handle after closing it", "wait_ready");
101 r = guestfs_wait_ready (g);
103 rb_raise (e_Error, "%s", guestfs_last_error (g));
108 static VALUE ruby_guestfs_kill_subprocess (VALUE gv)
111 Data_Get_Struct (gv, guestfs_h, g);
113 rb_raise (rb_eArgError, "%s: used handle after closing it", "kill_subprocess");
118 r = guestfs_kill_subprocess (g);
120 rb_raise (e_Error, "%s", guestfs_last_error (g));
125 static VALUE ruby_guestfs_add_drive (VALUE gv, VALUE filenamev)
128 Data_Get_Struct (gv, guestfs_h, g);
130 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_drive");
132 const char *filename = StringValueCStr (filenamev);
134 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
135 "filename", "add_drive");
139 r = guestfs_add_drive (g, filename);
141 rb_raise (e_Error, "%s", guestfs_last_error (g));
146 static VALUE ruby_guestfs_add_cdrom (VALUE gv, VALUE filenamev)
149 Data_Get_Struct (gv, guestfs_h, g);
151 rb_raise (rb_eArgError, "%s: used handle after closing it", "add_cdrom");
153 const char *filename = StringValueCStr (filenamev);
155 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
156 "filename", "add_cdrom");
160 r = guestfs_add_cdrom (g, filename);
162 rb_raise (e_Error, "%s", guestfs_last_error (g));
167 static VALUE ruby_guestfs_config (VALUE gv, VALUE qemuparamv, VALUE qemuvaluev)
170 Data_Get_Struct (gv, guestfs_h, g);
172 rb_raise (rb_eArgError, "%s: used handle after closing it", "config");
174 const char *qemuparam = StringValueCStr (qemuparamv);
176 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
177 "qemuparam", "config");
178 const char *qemuvalue = StringValueCStr (qemuvaluev);
182 r = guestfs_config (g, qemuparam, qemuvalue);
184 rb_raise (e_Error, "%s", guestfs_last_error (g));
189 static VALUE ruby_guestfs_set_qemu (VALUE gv, VALUE qemuv)
192 Data_Get_Struct (gv, guestfs_h, g);
194 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_qemu");
196 const char *qemu = StringValueCStr (qemuv);
198 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
203 r = guestfs_set_qemu (g, qemu);
205 rb_raise (e_Error, "%s", guestfs_last_error (g));
210 static VALUE ruby_guestfs_get_qemu (VALUE gv)
213 Data_Get_Struct (gv, guestfs_h, g);
215 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_qemu");
220 r = guestfs_get_qemu (g);
222 rb_raise (e_Error, "%s", guestfs_last_error (g));
224 return rb_str_new2 (r);
227 static VALUE ruby_guestfs_set_path (VALUE gv, VALUE pathv)
230 Data_Get_Struct (gv, guestfs_h, g);
232 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_path");
234 const char *path = StringValueCStr (pathv);
236 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
241 r = guestfs_set_path (g, path);
243 rb_raise (e_Error, "%s", guestfs_last_error (g));
248 static VALUE ruby_guestfs_get_path (VALUE gv)
251 Data_Get_Struct (gv, guestfs_h, g);
253 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_path");
258 r = guestfs_get_path (g);
260 rb_raise (e_Error, "%s", guestfs_last_error (g));
262 return rb_str_new2 (r);
265 static VALUE ruby_guestfs_set_append (VALUE gv, VALUE appendv)
268 Data_Get_Struct (gv, guestfs_h, g);
270 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_append");
272 const char *append = StringValueCStr (appendv);
274 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
275 "append", "set_append");
279 r = guestfs_set_append (g, append);
281 rb_raise (e_Error, "%s", guestfs_last_error (g));
286 static VALUE ruby_guestfs_get_append (VALUE gv)
289 Data_Get_Struct (gv, guestfs_h, g);
291 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_append");
296 r = guestfs_get_append (g);
298 rb_raise (e_Error, "%s", guestfs_last_error (g));
300 return rb_str_new2 (r);
303 static VALUE ruby_guestfs_set_autosync (VALUE gv, VALUE autosyncv)
306 Data_Get_Struct (gv, guestfs_h, g);
308 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_autosync");
310 int autosync = NUM2INT (autosyncv);
314 r = guestfs_set_autosync (g, autosync);
316 rb_raise (e_Error, "%s", guestfs_last_error (g));
321 static VALUE ruby_guestfs_get_autosync (VALUE gv)
324 Data_Get_Struct (gv, guestfs_h, g);
326 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_autosync");
331 r = guestfs_get_autosync (g);
333 rb_raise (e_Error, "%s", guestfs_last_error (g));
338 static VALUE ruby_guestfs_set_verbose (VALUE gv, VALUE verbosev)
341 Data_Get_Struct (gv, guestfs_h, g);
343 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_verbose");
345 int verbose = NUM2INT (verbosev);
349 r = guestfs_set_verbose (g, verbose);
351 rb_raise (e_Error, "%s", guestfs_last_error (g));
356 static VALUE ruby_guestfs_get_verbose (VALUE gv)
359 Data_Get_Struct (gv, guestfs_h, g);
361 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_verbose");
366 r = guestfs_get_verbose (g);
368 rb_raise (e_Error, "%s", guestfs_last_error (g));
373 static VALUE ruby_guestfs_is_ready (VALUE gv)
376 Data_Get_Struct (gv, guestfs_h, g);
378 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_ready");
383 r = guestfs_is_ready (g);
385 rb_raise (e_Error, "%s", guestfs_last_error (g));
390 static VALUE ruby_guestfs_is_config (VALUE gv)
393 Data_Get_Struct (gv, guestfs_h, g);
395 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_config");
400 r = guestfs_is_config (g);
402 rb_raise (e_Error, "%s", guestfs_last_error (g));
407 static VALUE ruby_guestfs_is_launching (VALUE gv)
410 Data_Get_Struct (gv, guestfs_h, g);
412 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_launching");
417 r = guestfs_is_launching (g);
419 rb_raise (e_Error, "%s", guestfs_last_error (g));
424 static VALUE ruby_guestfs_is_busy (VALUE gv)
427 Data_Get_Struct (gv, guestfs_h, g);
429 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_busy");
434 r = guestfs_is_busy (g);
436 rb_raise (e_Error, "%s", guestfs_last_error (g));
441 static VALUE ruby_guestfs_get_state (VALUE gv)
444 Data_Get_Struct (gv, guestfs_h, g);
446 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_state");
451 r = guestfs_get_state (g);
453 rb_raise (e_Error, "%s", guestfs_last_error (g));
458 static VALUE ruby_guestfs_set_busy (VALUE gv)
461 Data_Get_Struct (gv, guestfs_h, g);
463 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_busy");
468 r = guestfs_set_busy (g);
470 rb_raise (e_Error, "%s", guestfs_last_error (g));
475 static VALUE ruby_guestfs_set_ready (VALUE gv)
478 Data_Get_Struct (gv, guestfs_h, g);
480 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_ready");
485 r = guestfs_set_ready (g);
487 rb_raise (e_Error, "%s", guestfs_last_error (g));
492 static VALUE ruby_guestfs_end_busy (VALUE gv)
495 Data_Get_Struct (gv, guestfs_h, g);
497 rb_raise (rb_eArgError, "%s: used handle after closing it", "end_busy");
502 r = guestfs_end_busy (g);
504 rb_raise (e_Error, "%s", guestfs_last_error (g));
509 static VALUE ruby_guestfs_mount (VALUE gv, VALUE devicev, VALUE mountpointv)
512 Data_Get_Struct (gv, guestfs_h, g);
514 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount");
516 const char *device = StringValueCStr (devicev);
518 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
520 const char *mountpoint = StringValueCStr (mountpointv);
522 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
523 "mountpoint", "mount");
527 r = guestfs_mount (g, device, mountpoint);
529 rb_raise (e_Error, "%s", guestfs_last_error (g));
534 static VALUE ruby_guestfs_sync (VALUE gv)
537 Data_Get_Struct (gv, guestfs_h, g);
539 rb_raise (rb_eArgError, "%s: used handle after closing it", "sync");
544 r = guestfs_sync (g);
546 rb_raise (e_Error, "%s", guestfs_last_error (g));
551 static VALUE ruby_guestfs_touch (VALUE gv, VALUE pathv)
554 Data_Get_Struct (gv, guestfs_h, g);
556 rb_raise (rb_eArgError, "%s: used handle after closing it", "touch");
558 const char *path = StringValueCStr (pathv);
560 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
565 r = guestfs_touch (g, path);
567 rb_raise (e_Error, "%s", guestfs_last_error (g));
572 static VALUE ruby_guestfs_cat (VALUE gv, VALUE pathv)
575 Data_Get_Struct (gv, guestfs_h, g);
577 rb_raise (rb_eArgError, "%s: used handle after closing it", "cat");
579 const char *path = StringValueCStr (pathv);
581 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
586 r = guestfs_cat (g, path);
588 rb_raise (e_Error, "%s", guestfs_last_error (g));
590 VALUE rv = rb_str_new2 (r);
595 static VALUE ruby_guestfs_ll (VALUE gv, VALUE directoryv)
598 Data_Get_Struct (gv, guestfs_h, g);
600 rb_raise (rb_eArgError, "%s: used handle after closing it", "ll");
602 const char *directory = StringValueCStr (directoryv);
604 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
609 r = guestfs_ll (g, directory);
611 rb_raise (e_Error, "%s", guestfs_last_error (g));
613 VALUE rv = rb_str_new2 (r);
618 static VALUE ruby_guestfs_ls (VALUE gv, VALUE directoryv)
621 Data_Get_Struct (gv, guestfs_h, g);
623 rb_raise (rb_eArgError, "%s: used handle after closing it", "ls");
625 const char *directory = StringValueCStr (directoryv);
627 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
632 r = guestfs_ls (g, directory);
634 rb_raise (e_Error, "%s", guestfs_last_error (g));
637 for (i = 0; r[i] != NULL; ++i) len++;
638 VALUE rv = rb_ary_new2 (len);
639 for (i = 0; r[i] != NULL; ++i) {
640 rb_ary_push (rv, rb_str_new2 (r[i]));
647 static VALUE ruby_guestfs_list_devices (VALUE gv)
650 Data_Get_Struct (gv, guestfs_h, g);
652 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_devices");
657 r = guestfs_list_devices (g);
659 rb_raise (e_Error, "%s", guestfs_last_error (g));
662 for (i = 0; r[i] != NULL; ++i) len++;
663 VALUE rv = rb_ary_new2 (len);
664 for (i = 0; r[i] != NULL; ++i) {
665 rb_ary_push (rv, rb_str_new2 (r[i]));
672 static VALUE ruby_guestfs_list_partitions (VALUE gv)
675 Data_Get_Struct (gv, guestfs_h, g);
677 rb_raise (rb_eArgError, "%s: used handle after closing it", "list_partitions");
682 r = guestfs_list_partitions (g);
684 rb_raise (e_Error, "%s", guestfs_last_error (g));
687 for (i = 0; r[i] != NULL; ++i) len++;
688 VALUE rv = rb_ary_new2 (len);
689 for (i = 0; r[i] != NULL; ++i) {
690 rb_ary_push (rv, rb_str_new2 (r[i]));
697 static VALUE ruby_guestfs_pvs (VALUE gv)
700 Data_Get_Struct (gv, guestfs_h, g);
702 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs");
709 rb_raise (e_Error, "%s", guestfs_last_error (g));
712 for (i = 0; r[i] != NULL; ++i) len++;
713 VALUE rv = rb_ary_new2 (len);
714 for (i = 0; r[i] != NULL; ++i) {
715 rb_ary_push (rv, rb_str_new2 (r[i]));
722 static VALUE ruby_guestfs_vgs (VALUE gv)
725 Data_Get_Struct (gv, guestfs_h, g);
727 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs");
734 rb_raise (e_Error, "%s", guestfs_last_error (g));
737 for (i = 0; r[i] != NULL; ++i) len++;
738 VALUE rv = rb_ary_new2 (len);
739 for (i = 0; r[i] != NULL; ++i) {
740 rb_ary_push (rv, rb_str_new2 (r[i]));
747 static VALUE ruby_guestfs_lvs (VALUE gv)
750 Data_Get_Struct (gv, guestfs_h, g);
752 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs");
759 rb_raise (e_Error, "%s", guestfs_last_error (g));
762 for (i = 0; r[i] != NULL; ++i) len++;
763 VALUE rv = rb_ary_new2 (len);
764 for (i = 0; r[i] != NULL; ++i) {
765 rb_ary_push (rv, rb_str_new2 (r[i]));
772 static VALUE ruby_guestfs_pvs_full (VALUE gv)
775 Data_Get_Struct (gv, guestfs_h, g);
777 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvs_full");
780 struct guestfs_lvm_pv_list *r;
782 r = guestfs_pvs_full (g);
784 rb_raise (e_Error, "%s", guestfs_last_error (g));
786 VALUE rv = rb_ary_new2 (r->len);
788 for (i = 0; i < r->len; ++i) {
789 VALUE hv = rb_hash_new ();
790 rb_hash_aset (rv, rb_str_new2 ("pv_name"), rb_str_new2 (r->val[i].pv_name));
791 rb_hash_aset (rv, rb_str_new2 ("pv_uuid"), rb_str_new (r->val[i].pv_uuid, 32));
792 rb_hash_aset (rv, rb_str_new2 ("pv_fmt"), rb_str_new2 (r->val[i].pv_fmt));
793 rb_hash_aset (rv, rb_str_new2 ("pv_size"), ULL2NUM (r->val[i].pv_size));
794 rb_hash_aset (rv, rb_str_new2 ("dev_size"), ULL2NUM (r->val[i].dev_size));
795 rb_hash_aset (rv, rb_str_new2 ("pv_free"), ULL2NUM (r->val[i].pv_free));
796 rb_hash_aset (rv, rb_str_new2 ("pv_used"), ULL2NUM (r->val[i].pv_used));
797 rb_hash_aset (rv, rb_str_new2 ("pv_attr"), rb_str_new2 (r->val[i].pv_attr));
798 rb_hash_aset (rv, rb_str_new2 ("pv_pe_count"), ULL2NUM (r->val[i].pv_pe_count));
799 rb_hash_aset (rv, rb_str_new2 ("pv_pe_alloc_count"), ULL2NUM (r->val[i].pv_pe_alloc_count));
800 rb_hash_aset (rv, rb_str_new2 ("pv_tags"), rb_str_new2 (r->val[i].pv_tags));
801 rb_hash_aset (rv, rb_str_new2 ("pe_start"), ULL2NUM (r->val[i].pe_start));
802 rb_hash_aset (rv, rb_str_new2 ("pv_mda_count"), ULL2NUM (r->val[i].pv_mda_count));
803 rb_hash_aset (rv, rb_str_new2 ("pv_mda_free"), ULL2NUM (r->val[i].pv_mda_free));
804 rb_ary_push (rv, hv);
806 guestfs_free_lvm_pv_list (r);
810 static VALUE ruby_guestfs_vgs_full (VALUE gv)
813 Data_Get_Struct (gv, guestfs_h, g);
815 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgs_full");
818 struct guestfs_lvm_vg_list *r;
820 r = guestfs_vgs_full (g);
822 rb_raise (e_Error, "%s", guestfs_last_error (g));
824 VALUE rv = rb_ary_new2 (r->len);
826 for (i = 0; i < r->len; ++i) {
827 VALUE hv = rb_hash_new ();
828 rb_hash_aset (rv, rb_str_new2 ("vg_name"), rb_str_new2 (r->val[i].vg_name));
829 rb_hash_aset (rv, rb_str_new2 ("vg_uuid"), rb_str_new (r->val[i].vg_uuid, 32));
830 rb_hash_aset (rv, rb_str_new2 ("vg_fmt"), rb_str_new2 (r->val[i].vg_fmt));
831 rb_hash_aset (rv, rb_str_new2 ("vg_attr"), rb_str_new2 (r->val[i].vg_attr));
832 rb_hash_aset (rv, rb_str_new2 ("vg_size"), ULL2NUM (r->val[i].vg_size));
833 rb_hash_aset (rv, rb_str_new2 ("vg_free"), ULL2NUM (r->val[i].vg_free));
834 rb_hash_aset (rv, rb_str_new2 ("vg_sysid"), rb_str_new2 (r->val[i].vg_sysid));
835 rb_hash_aset (rv, rb_str_new2 ("vg_extent_size"), ULL2NUM (r->val[i].vg_extent_size));
836 rb_hash_aset (rv, rb_str_new2 ("vg_extent_count"), ULL2NUM (r->val[i].vg_extent_count));
837 rb_hash_aset (rv, rb_str_new2 ("vg_free_count"), ULL2NUM (r->val[i].vg_free_count));
838 rb_hash_aset (rv, rb_str_new2 ("max_lv"), ULL2NUM (r->val[i].max_lv));
839 rb_hash_aset (rv, rb_str_new2 ("max_pv"), ULL2NUM (r->val[i].max_pv));
840 rb_hash_aset (rv, rb_str_new2 ("pv_count"), ULL2NUM (r->val[i].pv_count));
841 rb_hash_aset (rv, rb_str_new2 ("lv_count"), ULL2NUM (r->val[i].lv_count));
842 rb_hash_aset (rv, rb_str_new2 ("snap_count"), ULL2NUM (r->val[i].snap_count));
843 rb_hash_aset (rv, rb_str_new2 ("vg_seqno"), ULL2NUM (r->val[i].vg_seqno));
844 rb_hash_aset (rv, rb_str_new2 ("vg_tags"), rb_str_new2 (r->val[i].vg_tags));
845 rb_hash_aset (rv, rb_str_new2 ("vg_mda_count"), ULL2NUM (r->val[i].vg_mda_count));
846 rb_hash_aset (rv, rb_str_new2 ("vg_mda_free"), ULL2NUM (r->val[i].vg_mda_free));
847 rb_ary_push (rv, hv);
849 guestfs_free_lvm_vg_list (r);
853 static VALUE ruby_guestfs_lvs_full (VALUE gv)
856 Data_Get_Struct (gv, guestfs_h, g);
858 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvs_full");
861 struct guestfs_lvm_lv_list *r;
863 r = guestfs_lvs_full (g);
865 rb_raise (e_Error, "%s", guestfs_last_error (g));
867 VALUE rv = rb_ary_new2 (r->len);
869 for (i = 0; i < r->len; ++i) {
870 VALUE hv = rb_hash_new ();
871 rb_hash_aset (rv, rb_str_new2 ("lv_name"), rb_str_new2 (r->val[i].lv_name));
872 rb_hash_aset (rv, rb_str_new2 ("lv_uuid"), rb_str_new (r->val[i].lv_uuid, 32));
873 rb_hash_aset (rv, rb_str_new2 ("lv_attr"), rb_str_new2 (r->val[i].lv_attr));
874 rb_hash_aset (rv, rb_str_new2 ("lv_major"), ULL2NUM (r->val[i].lv_major));
875 rb_hash_aset (rv, rb_str_new2 ("lv_minor"), ULL2NUM (r->val[i].lv_minor));
876 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_major"), ULL2NUM (r->val[i].lv_kernel_major));
877 rb_hash_aset (rv, rb_str_new2 ("lv_kernel_minor"), ULL2NUM (r->val[i].lv_kernel_minor));
878 rb_hash_aset (rv, rb_str_new2 ("lv_size"), ULL2NUM (r->val[i].lv_size));
879 rb_hash_aset (rv, rb_str_new2 ("seg_count"), ULL2NUM (r->val[i].seg_count));
880 rb_hash_aset (rv, rb_str_new2 ("origin"), rb_str_new2 (r->val[i].origin));
881 rb_hash_aset (rv, rb_str_new2 ("snap_percent"), rb_dbl2big (r->val[i].snap_percent));
882 rb_hash_aset (rv, rb_str_new2 ("copy_percent"), rb_dbl2big (r->val[i].copy_percent));
883 rb_hash_aset (rv, rb_str_new2 ("move_pv"), rb_str_new2 (r->val[i].move_pv));
884 rb_hash_aset (rv, rb_str_new2 ("lv_tags"), rb_str_new2 (r->val[i].lv_tags));
885 rb_hash_aset (rv, rb_str_new2 ("mirror_log"), rb_str_new2 (r->val[i].mirror_log));
886 rb_hash_aset (rv, rb_str_new2 ("modules"), rb_str_new2 (r->val[i].modules));
887 rb_ary_push (rv, hv);
889 guestfs_free_lvm_lv_list (r);
893 static VALUE ruby_guestfs_read_lines (VALUE gv, VALUE pathv)
896 Data_Get_Struct (gv, guestfs_h, g);
898 rb_raise (rb_eArgError, "%s: used handle after closing it", "read_lines");
900 const char *path = StringValueCStr (pathv);
902 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
903 "path", "read_lines");
907 r = guestfs_read_lines (g, path);
909 rb_raise (e_Error, "%s", guestfs_last_error (g));
912 for (i = 0; r[i] != NULL; ++i) len++;
913 VALUE rv = rb_ary_new2 (len);
914 for (i = 0; r[i] != NULL; ++i) {
915 rb_ary_push (rv, rb_str_new2 (r[i]));
922 static VALUE ruby_guestfs_aug_init (VALUE gv, VALUE rootv, VALUE flagsv)
925 Data_Get_Struct (gv, guestfs_h, g);
927 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_init");
929 const char *root = StringValueCStr (rootv);
931 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
933 int flags = NUM2INT (flagsv);
937 r = guestfs_aug_init (g, root, flags);
939 rb_raise (e_Error, "%s", guestfs_last_error (g));
944 static VALUE ruby_guestfs_aug_close (VALUE gv)
947 Data_Get_Struct (gv, guestfs_h, g);
949 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_close");
954 r = guestfs_aug_close (g);
956 rb_raise (e_Error, "%s", guestfs_last_error (g));
961 static VALUE ruby_guestfs_aug_defvar (VALUE gv, VALUE namev, VALUE exprv)
964 Data_Get_Struct (gv, guestfs_h, g);
966 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defvar");
968 const char *name = StringValueCStr (namev);
970 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
971 "name", "aug_defvar");
972 const char *expr = StringValueCStr (exprv);
976 r = guestfs_aug_defvar (g, name, expr);
978 rb_raise (e_Error, "%s", guestfs_last_error (g));
983 static VALUE ruby_guestfs_aug_defnode (VALUE gv, VALUE namev, VALUE exprv, VALUE valv)
986 Data_Get_Struct (gv, guestfs_h, g);
988 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_defnode");
990 const char *name = StringValueCStr (namev);
992 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
993 "name", "aug_defnode");
994 const char *expr = StringValueCStr (exprv);
996 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
997 "expr", "aug_defnode");
998 const char *val = StringValueCStr (valv);
1000 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1001 "val", "aug_defnode");
1003 struct guestfs_int_bool *r;
1005 r = guestfs_aug_defnode (g, name, expr, val);
1007 rb_raise (e_Error, "%s", guestfs_last_error (g));
1009 VALUE rv = rb_ary_new2 (2);
1010 rb_ary_push (rv, INT2NUM (r->i));
1011 rb_ary_push (rv, INT2NUM (r->b));
1012 guestfs_free_int_bool (r);
1016 static VALUE ruby_guestfs_aug_get (VALUE gv, VALUE pathv)
1019 Data_Get_Struct (gv, guestfs_h, g);
1021 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_get");
1023 const char *path = StringValueCStr (pathv);
1025 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1030 r = guestfs_aug_get (g, path);
1032 rb_raise (e_Error, "%s", guestfs_last_error (g));
1034 VALUE rv = rb_str_new2 (r);
1039 static VALUE ruby_guestfs_aug_set (VALUE gv, VALUE pathv, VALUE valv)
1042 Data_Get_Struct (gv, guestfs_h, g);
1044 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_set");
1046 const char *path = StringValueCStr (pathv);
1048 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1050 const char *val = StringValueCStr (valv);
1052 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1057 r = guestfs_aug_set (g, path, val);
1059 rb_raise (e_Error, "%s", guestfs_last_error (g));
1064 static VALUE ruby_guestfs_aug_insert (VALUE gv, VALUE pathv, VALUE labelv, VALUE beforev)
1067 Data_Get_Struct (gv, guestfs_h, g);
1069 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_insert");
1071 const char *path = StringValueCStr (pathv);
1073 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1074 "path", "aug_insert");
1075 const char *label = StringValueCStr (labelv);
1077 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1078 "label", "aug_insert");
1079 int before = NUM2INT (beforev);
1083 r = guestfs_aug_insert (g, path, label, before);
1085 rb_raise (e_Error, "%s", guestfs_last_error (g));
1090 static VALUE ruby_guestfs_aug_rm (VALUE gv, VALUE pathv)
1093 Data_Get_Struct (gv, guestfs_h, g);
1095 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_rm");
1097 const char *path = StringValueCStr (pathv);
1099 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1104 r = guestfs_aug_rm (g, path);
1106 rb_raise (e_Error, "%s", guestfs_last_error (g));
1111 static VALUE ruby_guestfs_aug_mv (VALUE gv, VALUE srcv, VALUE destv)
1114 Data_Get_Struct (gv, guestfs_h, g);
1116 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_mv");
1118 const char *src = StringValueCStr (srcv);
1120 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1122 const char *dest = StringValueCStr (destv);
1124 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1129 r = guestfs_aug_mv (g, src, dest);
1131 rb_raise (e_Error, "%s", guestfs_last_error (g));
1136 static VALUE ruby_guestfs_aug_match (VALUE gv, VALUE pathv)
1139 Data_Get_Struct (gv, guestfs_h, g);
1141 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_match");
1143 const char *path = StringValueCStr (pathv);
1145 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1146 "path", "aug_match");
1150 r = guestfs_aug_match (g, path);
1152 rb_raise (e_Error, "%s", guestfs_last_error (g));
1155 for (i = 0; r[i] != NULL; ++i) len++;
1156 VALUE rv = rb_ary_new2 (len);
1157 for (i = 0; r[i] != NULL; ++i) {
1158 rb_ary_push (rv, rb_str_new2 (r[i]));
1165 static VALUE ruby_guestfs_aug_save (VALUE gv)
1168 Data_Get_Struct (gv, guestfs_h, g);
1170 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_save");
1175 r = guestfs_aug_save (g);
1177 rb_raise (e_Error, "%s", guestfs_last_error (g));
1182 static VALUE ruby_guestfs_aug_load (VALUE gv)
1185 Data_Get_Struct (gv, guestfs_h, g);
1187 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_load");
1192 r = guestfs_aug_load (g);
1194 rb_raise (e_Error, "%s", guestfs_last_error (g));
1199 static VALUE ruby_guestfs_aug_ls (VALUE gv, VALUE pathv)
1202 Data_Get_Struct (gv, guestfs_h, g);
1204 rb_raise (rb_eArgError, "%s: used handle after closing it", "aug_ls");
1206 const char *path = StringValueCStr (pathv);
1208 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1213 r = guestfs_aug_ls (g, path);
1215 rb_raise (e_Error, "%s", guestfs_last_error (g));
1218 for (i = 0; r[i] != NULL; ++i) len++;
1219 VALUE rv = rb_ary_new2 (len);
1220 for (i = 0; r[i] != NULL; ++i) {
1221 rb_ary_push (rv, rb_str_new2 (r[i]));
1228 static VALUE ruby_guestfs_rm (VALUE gv, VALUE pathv)
1231 Data_Get_Struct (gv, guestfs_h, g);
1233 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm");
1235 const char *path = StringValueCStr (pathv);
1237 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1242 r = guestfs_rm (g, path);
1244 rb_raise (e_Error, "%s", guestfs_last_error (g));
1249 static VALUE ruby_guestfs_rmdir (VALUE gv, VALUE pathv)
1252 Data_Get_Struct (gv, guestfs_h, g);
1254 rb_raise (rb_eArgError, "%s: used handle after closing it", "rmdir");
1256 const char *path = StringValueCStr (pathv);
1258 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1263 r = guestfs_rmdir (g, path);
1265 rb_raise (e_Error, "%s", guestfs_last_error (g));
1270 static VALUE ruby_guestfs_rm_rf (VALUE gv, VALUE pathv)
1273 Data_Get_Struct (gv, guestfs_h, g);
1275 rb_raise (rb_eArgError, "%s: used handle after closing it", "rm_rf");
1277 const char *path = StringValueCStr (pathv);
1279 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1284 r = guestfs_rm_rf (g, path);
1286 rb_raise (e_Error, "%s", guestfs_last_error (g));
1291 static VALUE ruby_guestfs_mkdir (VALUE gv, VALUE pathv)
1294 Data_Get_Struct (gv, guestfs_h, g);
1296 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir");
1298 const char *path = StringValueCStr (pathv);
1300 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1305 r = guestfs_mkdir (g, path);
1307 rb_raise (e_Error, "%s", guestfs_last_error (g));
1312 static VALUE ruby_guestfs_mkdir_p (VALUE gv, VALUE pathv)
1315 Data_Get_Struct (gv, guestfs_h, g);
1317 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkdir_p");
1319 const char *path = StringValueCStr (pathv);
1321 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1326 r = guestfs_mkdir_p (g, path);
1328 rb_raise (e_Error, "%s", guestfs_last_error (g));
1333 static VALUE ruby_guestfs_chmod (VALUE gv, VALUE modev, VALUE pathv)
1336 Data_Get_Struct (gv, guestfs_h, g);
1338 rb_raise (rb_eArgError, "%s: used handle after closing it", "chmod");
1340 int mode = NUM2INT (modev);
1341 const char *path = StringValueCStr (pathv);
1343 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1348 r = guestfs_chmod (g, mode, path);
1350 rb_raise (e_Error, "%s", guestfs_last_error (g));
1355 static VALUE ruby_guestfs_chown (VALUE gv, VALUE ownerv, VALUE groupv, VALUE pathv)
1358 Data_Get_Struct (gv, guestfs_h, g);
1360 rb_raise (rb_eArgError, "%s: used handle after closing it", "chown");
1362 int owner = NUM2INT (ownerv);
1363 int group = NUM2INT (groupv);
1364 const char *path = StringValueCStr (pathv);
1366 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1371 r = guestfs_chown (g, owner, group, path);
1373 rb_raise (e_Error, "%s", guestfs_last_error (g));
1378 static VALUE ruby_guestfs_exists (VALUE gv, VALUE pathv)
1381 Data_Get_Struct (gv, guestfs_h, g);
1383 rb_raise (rb_eArgError, "%s: used handle after closing it", "exists");
1385 const char *path = StringValueCStr (pathv);
1387 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1392 r = guestfs_exists (g, path);
1394 rb_raise (e_Error, "%s", guestfs_last_error (g));
1399 static VALUE ruby_guestfs_is_file (VALUE gv, VALUE pathv)
1402 Data_Get_Struct (gv, guestfs_h, g);
1404 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_file");
1406 const char *path = StringValueCStr (pathv);
1408 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1413 r = guestfs_is_file (g, path);
1415 rb_raise (e_Error, "%s", guestfs_last_error (g));
1420 static VALUE ruby_guestfs_is_dir (VALUE gv, VALUE pathv)
1423 Data_Get_Struct (gv, guestfs_h, g);
1425 rb_raise (rb_eArgError, "%s: used handle after closing it", "is_dir");
1427 const char *path = StringValueCStr (pathv);
1429 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1434 r = guestfs_is_dir (g, path);
1436 rb_raise (e_Error, "%s", guestfs_last_error (g));
1441 static VALUE ruby_guestfs_pvcreate (VALUE gv, VALUE devicev)
1444 Data_Get_Struct (gv, guestfs_h, g);
1446 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvcreate");
1448 const char *device = StringValueCStr (devicev);
1450 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1451 "device", "pvcreate");
1455 r = guestfs_pvcreate (g, device);
1457 rb_raise (e_Error, "%s", guestfs_last_error (g));
1462 static VALUE ruby_guestfs_vgcreate (VALUE gv, VALUE volgroupv, VALUE physvolsv)
1465 Data_Get_Struct (gv, guestfs_h, g);
1467 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgcreate");
1469 const char *volgroup = StringValueCStr (volgroupv);
1471 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1472 "volgroup", "vgcreate");
1475 len = RARRAY_LEN (physvolsv);
1476 physvols = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1477 for (i = 0; i < len; ++i) {
1478 VALUE v = rb_ary_entry (physvolsv, i);
1479 physvols[i] = StringValueCStr (v);
1481 physvols[len] = NULL;
1486 r = guestfs_vgcreate (g, volgroup, physvols);
1489 rb_raise (e_Error, "%s", guestfs_last_error (g));
1494 static VALUE ruby_guestfs_lvcreate (VALUE gv, VALUE logvolv, VALUE volgroupv, VALUE mbytesv)
1497 Data_Get_Struct (gv, guestfs_h, g);
1499 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvcreate");
1501 const char *logvol = StringValueCStr (logvolv);
1503 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1504 "logvol", "lvcreate");
1505 const char *volgroup = StringValueCStr (volgroupv);
1507 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1508 "volgroup", "lvcreate");
1509 int mbytes = NUM2INT (mbytesv);
1513 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1515 rb_raise (e_Error, "%s", guestfs_last_error (g));
1520 static VALUE ruby_guestfs_mkfs (VALUE gv, VALUE fstypev, VALUE devicev)
1523 Data_Get_Struct (gv, guestfs_h, g);
1525 rb_raise (rb_eArgError, "%s: used handle after closing it", "mkfs");
1527 const char *fstype = StringValueCStr (fstypev);
1529 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1531 const char *device = StringValueCStr (devicev);
1533 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1538 r = guestfs_mkfs (g, fstype, device);
1540 rb_raise (e_Error, "%s", guestfs_last_error (g));
1545 static VALUE ruby_guestfs_sfdisk (VALUE gv, VALUE devicev, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linesv)
1548 Data_Get_Struct (gv, guestfs_h, g);
1550 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk");
1552 const char *device = StringValueCStr (devicev);
1554 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1555 "device", "sfdisk");
1556 int cyls = NUM2INT (cylsv);
1557 int heads = NUM2INT (headsv);
1558 int sectors = NUM2INT (sectorsv);
1561 len = RARRAY_LEN (linesv);
1562 lines = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1563 for (i = 0; i < len; ++i) {
1564 VALUE v = rb_ary_entry (linesv, i);
1565 lines[i] = StringValueCStr (v);
1572 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1575 rb_raise (e_Error, "%s", guestfs_last_error (g));
1580 static VALUE ruby_guestfs_write_file (VALUE gv, VALUE pathv, VALUE contentv, VALUE sizev)
1583 Data_Get_Struct (gv, guestfs_h, g);
1585 rb_raise (rb_eArgError, "%s: used handle after closing it", "write_file");
1587 const char *path = StringValueCStr (pathv);
1589 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1590 "path", "write_file");
1591 const char *content = StringValueCStr (contentv);
1593 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1594 "content", "write_file");
1595 int size = NUM2INT (sizev);
1599 r = guestfs_write_file (g, path, content, size);
1601 rb_raise (e_Error, "%s", guestfs_last_error (g));
1606 static VALUE ruby_guestfs_umount (VALUE gv, VALUE pathordevicev)
1609 Data_Get_Struct (gv, guestfs_h, g);
1611 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount");
1613 const char *pathordevice = StringValueCStr (pathordevicev);
1615 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1616 "pathordevice", "umount");
1620 r = guestfs_umount (g, pathordevice);
1622 rb_raise (e_Error, "%s", guestfs_last_error (g));
1627 static VALUE ruby_guestfs_mounts (VALUE gv)
1630 Data_Get_Struct (gv, guestfs_h, g);
1632 rb_raise (rb_eArgError, "%s: used handle after closing it", "mounts");
1637 r = guestfs_mounts (g);
1639 rb_raise (e_Error, "%s", guestfs_last_error (g));
1642 for (i = 0; r[i] != NULL; ++i) len++;
1643 VALUE rv = rb_ary_new2 (len);
1644 for (i = 0; r[i] != NULL; ++i) {
1645 rb_ary_push (rv, rb_str_new2 (r[i]));
1652 static VALUE ruby_guestfs_umount_all (VALUE gv)
1655 Data_Get_Struct (gv, guestfs_h, g);
1657 rb_raise (rb_eArgError, "%s: used handle after closing it", "umount_all");
1662 r = guestfs_umount_all (g);
1664 rb_raise (e_Error, "%s", guestfs_last_error (g));
1669 static VALUE ruby_guestfs_lvm_remove_all (VALUE gv)
1672 Data_Get_Struct (gv, guestfs_h, g);
1674 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvm_remove_all");
1679 r = guestfs_lvm_remove_all (g);
1681 rb_raise (e_Error, "%s", guestfs_last_error (g));
1686 static VALUE ruby_guestfs_file (VALUE gv, VALUE pathv)
1689 Data_Get_Struct (gv, guestfs_h, g);
1691 rb_raise (rb_eArgError, "%s: used handle after closing it", "file");
1693 const char *path = StringValueCStr (pathv);
1695 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1700 r = guestfs_file (g, path);
1702 rb_raise (e_Error, "%s", guestfs_last_error (g));
1704 VALUE rv = rb_str_new2 (r);
1709 static VALUE ruby_guestfs_command (VALUE gv, VALUE argumentsv)
1712 Data_Get_Struct (gv, guestfs_h, g);
1714 rb_raise (rb_eArgError, "%s: used handle after closing it", "command");
1718 len = RARRAY_LEN (argumentsv);
1719 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1720 for (i = 0; i < len; ++i) {
1721 VALUE v = rb_ary_entry (argumentsv, i);
1722 arguments[i] = StringValueCStr (v);
1724 arguments[len] = NULL;
1729 r = guestfs_command (g, arguments);
1732 rb_raise (e_Error, "%s", guestfs_last_error (g));
1734 VALUE rv = rb_str_new2 (r);
1739 static VALUE ruby_guestfs_command_lines (VALUE gv, VALUE argumentsv)
1742 Data_Get_Struct (gv, guestfs_h, g);
1744 rb_raise (rb_eArgError, "%s: used handle after closing it", "command_lines");
1748 len = RARRAY_LEN (argumentsv);
1749 arguments = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
1750 for (i = 0; i < len; ++i) {
1751 VALUE v = rb_ary_entry (argumentsv, i);
1752 arguments[i] = StringValueCStr (v);
1754 arguments[len] = NULL;
1759 r = guestfs_command_lines (g, arguments);
1762 rb_raise (e_Error, "%s", guestfs_last_error (g));
1765 for (i = 0; r[i] != NULL; ++i) len++;
1766 VALUE rv = rb_ary_new2 (len);
1767 for (i = 0; r[i] != NULL; ++i) {
1768 rb_ary_push (rv, rb_str_new2 (r[i]));
1775 static VALUE ruby_guestfs_stat (VALUE gv, VALUE pathv)
1778 Data_Get_Struct (gv, guestfs_h, g);
1780 rb_raise (rb_eArgError, "%s: used handle after closing it", "stat");
1782 const char *path = StringValueCStr (pathv);
1784 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1787 struct guestfs_stat *r;
1789 r = guestfs_stat (g, path);
1791 rb_raise (e_Error, "%s", guestfs_last_error (g));
1793 VALUE rv = rb_hash_new ();
1794 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1795 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1796 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1797 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1798 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1799 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1800 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1801 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1802 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1803 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1804 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1805 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1806 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1811 static VALUE ruby_guestfs_lstat (VALUE gv, VALUE pathv)
1814 Data_Get_Struct (gv, guestfs_h, g);
1816 rb_raise (rb_eArgError, "%s: used handle after closing it", "lstat");
1818 const char *path = StringValueCStr (pathv);
1820 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1823 struct guestfs_stat *r;
1825 r = guestfs_lstat (g, path);
1827 rb_raise (e_Error, "%s", guestfs_last_error (g));
1829 VALUE rv = rb_hash_new ();
1830 rb_hash_aset (rv, rb_str_new2 ("dev"), ULL2NUM (r->dev));
1831 rb_hash_aset (rv, rb_str_new2 ("ino"), ULL2NUM (r->ino));
1832 rb_hash_aset (rv, rb_str_new2 ("mode"), ULL2NUM (r->mode));
1833 rb_hash_aset (rv, rb_str_new2 ("nlink"), ULL2NUM (r->nlink));
1834 rb_hash_aset (rv, rb_str_new2 ("uid"), ULL2NUM (r->uid));
1835 rb_hash_aset (rv, rb_str_new2 ("gid"), ULL2NUM (r->gid));
1836 rb_hash_aset (rv, rb_str_new2 ("rdev"), ULL2NUM (r->rdev));
1837 rb_hash_aset (rv, rb_str_new2 ("size"), ULL2NUM (r->size));
1838 rb_hash_aset (rv, rb_str_new2 ("blksize"), ULL2NUM (r->blksize));
1839 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1840 rb_hash_aset (rv, rb_str_new2 ("atime"), ULL2NUM (r->atime));
1841 rb_hash_aset (rv, rb_str_new2 ("mtime"), ULL2NUM (r->mtime));
1842 rb_hash_aset (rv, rb_str_new2 ("ctime"), ULL2NUM (r->ctime));
1847 static VALUE ruby_guestfs_statvfs (VALUE gv, VALUE pathv)
1850 Data_Get_Struct (gv, guestfs_h, g);
1852 rb_raise (rb_eArgError, "%s: used handle after closing it", "statvfs");
1854 const char *path = StringValueCStr (pathv);
1856 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1859 struct guestfs_statvfs *r;
1861 r = guestfs_statvfs (g, path);
1863 rb_raise (e_Error, "%s", guestfs_last_error (g));
1865 VALUE rv = rb_hash_new ();
1866 rb_hash_aset (rv, rb_str_new2 ("bsize"), ULL2NUM (r->bsize));
1867 rb_hash_aset (rv, rb_str_new2 ("frsize"), ULL2NUM (r->frsize));
1868 rb_hash_aset (rv, rb_str_new2 ("blocks"), ULL2NUM (r->blocks));
1869 rb_hash_aset (rv, rb_str_new2 ("bfree"), ULL2NUM (r->bfree));
1870 rb_hash_aset (rv, rb_str_new2 ("bavail"), ULL2NUM (r->bavail));
1871 rb_hash_aset (rv, rb_str_new2 ("files"), ULL2NUM (r->files));
1872 rb_hash_aset (rv, rb_str_new2 ("ffree"), ULL2NUM (r->ffree));
1873 rb_hash_aset (rv, rb_str_new2 ("favail"), ULL2NUM (r->favail));
1874 rb_hash_aset (rv, rb_str_new2 ("fsid"), ULL2NUM (r->fsid));
1875 rb_hash_aset (rv, rb_str_new2 ("flag"), ULL2NUM (r->flag));
1876 rb_hash_aset (rv, rb_str_new2 ("namemax"), ULL2NUM (r->namemax));
1881 static VALUE ruby_guestfs_tune2fs_l (VALUE gv, VALUE devicev)
1884 Data_Get_Struct (gv, guestfs_h, g);
1886 rb_raise (rb_eArgError, "%s: used handle after closing it", "tune2fs_l");
1888 const char *device = StringValueCStr (devicev);
1890 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1891 "device", "tune2fs_l");
1895 r = guestfs_tune2fs_l (g, device);
1897 rb_raise (e_Error, "%s", guestfs_last_error (g));
1899 VALUE rv = rb_hash_new ();
1901 for (i = 0; r[i] != NULL; i+=2) {
1902 rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));
1910 static VALUE ruby_guestfs_blockdev_setro (VALUE gv, VALUE devicev)
1913 Data_Get_Struct (gv, guestfs_h, g);
1915 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setro");
1917 const char *device = StringValueCStr (devicev);
1919 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1920 "device", "blockdev_setro");
1924 r = guestfs_blockdev_setro (g, device);
1926 rb_raise (e_Error, "%s", guestfs_last_error (g));
1931 static VALUE ruby_guestfs_blockdev_setrw (VALUE gv, VALUE devicev)
1934 Data_Get_Struct (gv, guestfs_h, g);
1936 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setrw");
1938 const char *device = StringValueCStr (devicev);
1940 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1941 "device", "blockdev_setrw");
1945 r = guestfs_blockdev_setrw (g, device);
1947 rb_raise (e_Error, "%s", guestfs_last_error (g));
1952 static VALUE ruby_guestfs_blockdev_getro (VALUE gv, VALUE devicev)
1955 Data_Get_Struct (gv, guestfs_h, g);
1957 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getro");
1959 const char *device = StringValueCStr (devicev);
1961 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1962 "device", "blockdev_getro");
1966 r = guestfs_blockdev_getro (g, device);
1968 rb_raise (e_Error, "%s", guestfs_last_error (g));
1973 static VALUE ruby_guestfs_blockdev_getss (VALUE gv, VALUE devicev)
1976 Data_Get_Struct (gv, guestfs_h, g);
1978 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getss");
1980 const char *device = StringValueCStr (devicev);
1982 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
1983 "device", "blockdev_getss");
1987 r = guestfs_blockdev_getss (g, device);
1989 rb_raise (e_Error, "%s", guestfs_last_error (g));
1994 static VALUE ruby_guestfs_blockdev_getbsz (VALUE gv, VALUE devicev)
1997 Data_Get_Struct (gv, guestfs_h, g);
1999 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getbsz");
2001 const char *device = StringValueCStr (devicev);
2003 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2004 "device", "blockdev_getbsz");
2008 r = guestfs_blockdev_getbsz (g, device);
2010 rb_raise (e_Error, "%s", guestfs_last_error (g));
2015 static VALUE ruby_guestfs_blockdev_setbsz (VALUE gv, VALUE devicev, VALUE blocksizev)
2018 Data_Get_Struct (gv, guestfs_h, g);
2020 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_setbsz");
2022 const char *device = StringValueCStr (devicev);
2024 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2025 "device", "blockdev_setbsz");
2026 int blocksize = NUM2INT (blocksizev);
2030 r = guestfs_blockdev_setbsz (g, device, blocksize);
2032 rb_raise (e_Error, "%s", guestfs_last_error (g));
2037 static VALUE ruby_guestfs_blockdev_getsz (VALUE gv, VALUE devicev)
2040 Data_Get_Struct (gv, guestfs_h, g);
2042 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsz");
2044 const char *device = StringValueCStr (devicev);
2046 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2047 "device", "blockdev_getsz");
2051 r = guestfs_blockdev_getsz (g, device);
2053 rb_raise (e_Error, "%s", guestfs_last_error (g));
2058 static VALUE ruby_guestfs_blockdev_getsize64 (VALUE gv, VALUE devicev)
2061 Data_Get_Struct (gv, guestfs_h, g);
2063 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_getsize64");
2065 const char *device = StringValueCStr (devicev);
2067 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2068 "device", "blockdev_getsize64");
2072 r = guestfs_blockdev_getsize64 (g, device);
2074 rb_raise (e_Error, "%s", guestfs_last_error (g));
2079 static VALUE ruby_guestfs_blockdev_flushbufs (VALUE gv, VALUE devicev)
2082 Data_Get_Struct (gv, guestfs_h, g);
2084 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_flushbufs");
2086 const char *device = StringValueCStr (devicev);
2088 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2089 "device", "blockdev_flushbufs");
2093 r = guestfs_blockdev_flushbufs (g, device);
2095 rb_raise (e_Error, "%s", guestfs_last_error (g));
2100 static VALUE ruby_guestfs_blockdev_rereadpt (VALUE gv, VALUE devicev)
2103 Data_Get_Struct (gv, guestfs_h, g);
2105 rb_raise (rb_eArgError, "%s: used handle after closing it", "blockdev_rereadpt");
2107 const char *device = StringValueCStr (devicev);
2109 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2110 "device", "blockdev_rereadpt");
2114 r = guestfs_blockdev_rereadpt (g, device);
2116 rb_raise (e_Error, "%s", guestfs_last_error (g));
2121 static VALUE ruby_guestfs_upload (VALUE gv, VALUE filenamev, VALUE remotefilenamev)
2124 Data_Get_Struct (gv, guestfs_h, g);
2126 rb_raise (rb_eArgError, "%s: used handle after closing it", "upload");
2128 const char *filename = StringValueCStr (filenamev);
2130 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2131 "filename", "upload");
2132 const char *remotefilename = StringValueCStr (remotefilenamev);
2133 if (!remotefilename)
2134 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2135 "remotefilename", "upload");
2139 r = guestfs_upload (g, filename, remotefilename);
2141 rb_raise (e_Error, "%s", guestfs_last_error (g));
2146 static VALUE ruby_guestfs_download (VALUE gv, VALUE remotefilenamev, VALUE filenamev)
2149 Data_Get_Struct (gv, guestfs_h, g);
2151 rb_raise (rb_eArgError, "%s: used handle after closing it", "download");
2153 const char *remotefilename = StringValueCStr (remotefilenamev);
2154 if (!remotefilename)
2155 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2156 "remotefilename", "download");
2157 const char *filename = StringValueCStr (filenamev);
2159 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2160 "filename", "download");
2164 r = guestfs_download (g, remotefilename, filename);
2166 rb_raise (e_Error, "%s", guestfs_last_error (g));
2171 static VALUE ruby_guestfs_checksum (VALUE gv, VALUE csumtypev, VALUE pathv)
2174 Data_Get_Struct (gv, guestfs_h, g);
2176 rb_raise (rb_eArgError, "%s: used handle after closing it", "checksum");
2178 const char *csumtype = StringValueCStr (csumtypev);
2180 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2181 "csumtype", "checksum");
2182 const char *path = StringValueCStr (pathv);
2184 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2185 "path", "checksum");
2189 r = guestfs_checksum (g, csumtype, path);
2191 rb_raise (e_Error, "%s", guestfs_last_error (g));
2193 VALUE rv = rb_str_new2 (r);
2198 static VALUE ruby_guestfs_tar_in (VALUE gv, VALUE tarfilev, VALUE directoryv)
2201 Data_Get_Struct (gv, guestfs_h, g);
2203 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_in");
2205 const char *tarfile = StringValueCStr (tarfilev);
2207 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2208 "tarfile", "tar_in");
2209 const char *directory = StringValueCStr (directoryv);
2211 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2212 "directory", "tar_in");
2216 r = guestfs_tar_in (g, tarfile, directory);
2218 rb_raise (e_Error, "%s", guestfs_last_error (g));
2223 static VALUE ruby_guestfs_tar_out (VALUE gv, VALUE directoryv, VALUE tarfilev)
2226 Data_Get_Struct (gv, guestfs_h, g);
2228 rb_raise (rb_eArgError, "%s: used handle after closing it", "tar_out");
2230 const char *directory = StringValueCStr (directoryv);
2232 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2233 "directory", "tar_out");
2234 const char *tarfile = StringValueCStr (tarfilev);
2236 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2237 "tarfile", "tar_out");
2241 r = guestfs_tar_out (g, directory, tarfile);
2243 rb_raise (e_Error, "%s", guestfs_last_error (g));
2248 static VALUE ruby_guestfs_tgz_in (VALUE gv, VALUE tarballv, VALUE directoryv)
2251 Data_Get_Struct (gv, guestfs_h, g);
2253 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_in");
2255 const char *tarball = StringValueCStr (tarballv);
2257 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2258 "tarball", "tgz_in");
2259 const char *directory = StringValueCStr (directoryv);
2261 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2262 "directory", "tgz_in");
2266 r = guestfs_tgz_in (g, tarball, directory);
2268 rb_raise (e_Error, "%s", guestfs_last_error (g));
2273 static VALUE ruby_guestfs_tgz_out (VALUE gv, VALUE directoryv, VALUE tarballv)
2276 Data_Get_Struct (gv, guestfs_h, g);
2278 rb_raise (rb_eArgError, "%s: used handle after closing it", "tgz_out");
2280 const char *directory = StringValueCStr (directoryv);
2282 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2283 "directory", "tgz_out");
2284 const char *tarball = StringValueCStr (tarballv);
2286 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2287 "tarball", "tgz_out");
2291 r = guestfs_tgz_out (g, directory, tarball);
2293 rb_raise (e_Error, "%s", guestfs_last_error (g));
2298 static VALUE ruby_guestfs_mount_ro (VALUE gv, VALUE devicev, VALUE mountpointv)
2301 Data_Get_Struct (gv, guestfs_h, g);
2303 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_ro");
2305 const char *device = StringValueCStr (devicev);
2307 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2308 "device", "mount_ro");
2309 const char *mountpoint = StringValueCStr (mountpointv);
2311 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2312 "mountpoint", "mount_ro");
2316 r = guestfs_mount_ro (g, device, mountpoint);
2318 rb_raise (e_Error, "%s", guestfs_last_error (g));
2323 static VALUE ruby_guestfs_mount_options (VALUE gv, VALUE optionsv, VALUE devicev, VALUE mountpointv)
2326 Data_Get_Struct (gv, guestfs_h, g);
2328 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_options");
2330 const char *options = StringValueCStr (optionsv);
2332 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2333 "options", "mount_options");
2334 const char *device = StringValueCStr (devicev);
2336 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2337 "device", "mount_options");
2338 const char *mountpoint = StringValueCStr (mountpointv);
2340 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2341 "mountpoint", "mount_options");
2345 r = guestfs_mount_options (g, options, device, mountpoint);
2347 rb_raise (e_Error, "%s", guestfs_last_error (g));
2352 static VALUE ruby_guestfs_mount_vfs (VALUE gv, VALUE optionsv, VALUE vfstypev, VALUE devicev, VALUE mountpointv)
2355 Data_Get_Struct (gv, guestfs_h, g);
2357 rb_raise (rb_eArgError, "%s: used handle after closing it", "mount_vfs");
2359 const char *options = StringValueCStr (optionsv);
2361 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2362 "options", "mount_vfs");
2363 const char *vfstype = StringValueCStr (vfstypev);
2365 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2366 "vfstype", "mount_vfs");
2367 const char *device = StringValueCStr (devicev);
2369 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2370 "device", "mount_vfs");
2371 const char *mountpoint = StringValueCStr (mountpointv);
2373 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2374 "mountpoint", "mount_vfs");
2378 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2380 rb_raise (e_Error, "%s", guestfs_last_error (g));
2385 static VALUE ruby_guestfs_debug (VALUE gv, VALUE subcmdv, VALUE extraargsv)
2388 Data_Get_Struct (gv, guestfs_h, g);
2390 rb_raise (rb_eArgError, "%s: used handle after closing it", "debug");
2392 const char *subcmd = StringValueCStr (subcmdv);
2394 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2398 len = RARRAY_LEN (extraargsv);
2399 extraargs = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
2400 for (i = 0; i < len; ++i) {
2401 VALUE v = rb_ary_entry (extraargsv, i);
2402 extraargs[i] = StringValueCStr (v);
2404 extraargs[len] = NULL;
2409 r = guestfs_debug (g, subcmd, extraargs);
2412 rb_raise (e_Error, "%s", guestfs_last_error (g));
2414 VALUE rv = rb_str_new2 (r);
2419 static VALUE ruby_guestfs_lvremove (VALUE gv, VALUE devicev)
2422 Data_Get_Struct (gv, guestfs_h, g);
2424 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvremove");
2426 const char *device = StringValueCStr (devicev);
2428 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2429 "device", "lvremove");
2433 r = guestfs_lvremove (g, device);
2435 rb_raise (e_Error, "%s", guestfs_last_error (g));
2440 static VALUE ruby_guestfs_vgremove (VALUE gv, VALUE vgnamev)
2443 Data_Get_Struct (gv, guestfs_h, g);
2445 rb_raise (rb_eArgError, "%s: used handle after closing it", "vgremove");
2447 const char *vgname = StringValueCStr (vgnamev);
2449 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2450 "vgname", "vgremove");
2454 r = guestfs_vgremove (g, vgname);
2456 rb_raise (e_Error, "%s", guestfs_last_error (g));
2461 static VALUE ruby_guestfs_pvremove (VALUE gv, VALUE devicev)
2464 Data_Get_Struct (gv, guestfs_h, g);
2466 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvremove");
2468 const char *device = StringValueCStr (devicev);
2470 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2471 "device", "pvremove");
2475 r = guestfs_pvremove (g, device);
2477 rb_raise (e_Error, "%s", guestfs_last_error (g));
2482 static VALUE ruby_guestfs_set_e2label (VALUE gv, VALUE devicev, VALUE labelv)
2485 Data_Get_Struct (gv, guestfs_h, g);
2487 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2label");
2489 const char *device = StringValueCStr (devicev);
2491 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2492 "device", "set_e2label");
2493 const char *label = StringValueCStr (labelv);
2495 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2496 "label", "set_e2label");
2500 r = guestfs_set_e2label (g, device, label);
2502 rb_raise (e_Error, "%s", guestfs_last_error (g));
2507 static VALUE ruby_guestfs_get_e2label (VALUE gv, VALUE devicev)
2510 Data_Get_Struct (gv, guestfs_h, g);
2512 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2label");
2514 const char *device = StringValueCStr (devicev);
2516 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2517 "device", "get_e2label");
2521 r = guestfs_get_e2label (g, device);
2523 rb_raise (e_Error, "%s", guestfs_last_error (g));
2525 VALUE rv = rb_str_new2 (r);
2530 static VALUE ruby_guestfs_set_e2uuid (VALUE gv, VALUE devicev, VALUE uuidv)
2533 Data_Get_Struct (gv, guestfs_h, g);
2535 rb_raise (rb_eArgError, "%s: used handle after closing it", "set_e2uuid");
2537 const char *device = StringValueCStr (devicev);
2539 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2540 "device", "set_e2uuid");
2541 const char *uuid = StringValueCStr (uuidv);
2543 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2544 "uuid", "set_e2uuid");
2548 r = guestfs_set_e2uuid (g, device, uuid);
2550 rb_raise (e_Error, "%s", guestfs_last_error (g));
2555 static VALUE ruby_guestfs_get_e2uuid (VALUE gv, VALUE devicev)
2558 Data_Get_Struct (gv, guestfs_h, g);
2560 rb_raise (rb_eArgError, "%s: used handle after closing it", "get_e2uuid");
2562 const char *device = StringValueCStr (devicev);
2564 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2565 "device", "get_e2uuid");
2569 r = guestfs_get_e2uuid (g, device);
2571 rb_raise (e_Error, "%s", guestfs_last_error (g));
2573 VALUE rv = rb_str_new2 (r);
2578 static VALUE ruby_guestfs_fsck (VALUE gv, VALUE fstypev, VALUE devicev)
2581 Data_Get_Struct (gv, guestfs_h, g);
2583 rb_raise (rb_eArgError, "%s: used handle after closing it", "fsck");
2585 const char *fstype = StringValueCStr (fstypev);
2587 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2589 const char *device = StringValueCStr (devicev);
2591 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2596 r = guestfs_fsck (g, fstype, device);
2598 rb_raise (e_Error, "%s", guestfs_last_error (g));
2603 static VALUE ruby_guestfs_zero (VALUE gv, VALUE devicev)
2606 Data_Get_Struct (gv, guestfs_h, g);
2608 rb_raise (rb_eArgError, "%s: used handle after closing it", "zero");
2610 const char *device = StringValueCStr (devicev);
2612 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2617 r = guestfs_zero (g, device);
2619 rb_raise (e_Error, "%s", guestfs_last_error (g));
2624 static VALUE ruby_guestfs_grub_install (VALUE gv, VALUE rootv, VALUE devicev)
2627 Data_Get_Struct (gv, guestfs_h, g);
2629 rb_raise (rb_eArgError, "%s: used handle after closing it", "grub_install");
2631 const char *root = StringValueCStr (rootv);
2633 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2634 "root", "grub_install");
2635 const char *device = StringValueCStr (devicev);
2637 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2638 "device", "grub_install");
2642 r = guestfs_grub_install (g, root, device);
2644 rb_raise (e_Error, "%s", guestfs_last_error (g));
2649 static VALUE ruby_guestfs_cp (VALUE gv, VALUE srcv, VALUE destv)
2652 Data_Get_Struct (gv, guestfs_h, g);
2654 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp");
2656 const char *src = StringValueCStr (srcv);
2658 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2660 const char *dest = StringValueCStr (destv);
2662 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2667 r = guestfs_cp (g, src, dest);
2669 rb_raise (e_Error, "%s", guestfs_last_error (g));
2674 static VALUE ruby_guestfs_cp_a (VALUE gv, VALUE srcv, VALUE destv)
2677 Data_Get_Struct (gv, guestfs_h, g);
2679 rb_raise (rb_eArgError, "%s: used handle after closing it", "cp_a");
2681 const char *src = StringValueCStr (srcv);
2683 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2685 const char *dest = StringValueCStr (destv);
2687 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2692 r = guestfs_cp_a (g, src, dest);
2694 rb_raise (e_Error, "%s", guestfs_last_error (g));
2699 static VALUE ruby_guestfs_mv (VALUE gv, VALUE srcv, VALUE destv)
2702 Data_Get_Struct (gv, guestfs_h, g);
2704 rb_raise (rb_eArgError, "%s: used handle after closing it", "mv");
2706 const char *src = StringValueCStr (srcv);
2708 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2710 const char *dest = StringValueCStr (destv);
2712 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2717 r = guestfs_mv (g, src, dest);
2719 rb_raise (e_Error, "%s", guestfs_last_error (g));
2724 static VALUE ruby_guestfs_drop_caches (VALUE gv, VALUE whattodropv)
2727 Data_Get_Struct (gv, guestfs_h, g);
2729 rb_raise (rb_eArgError, "%s: used handle after closing it", "drop_caches");
2731 int whattodrop = NUM2INT (whattodropv);
2735 r = guestfs_drop_caches (g, whattodrop);
2737 rb_raise (e_Error, "%s", guestfs_last_error (g));
2742 static VALUE ruby_guestfs_dmesg (VALUE gv)
2745 Data_Get_Struct (gv, guestfs_h, g);
2747 rb_raise (rb_eArgError, "%s: used handle after closing it", "dmesg");
2752 r = guestfs_dmesg (g);
2754 rb_raise (e_Error, "%s", guestfs_last_error (g));
2756 VALUE rv = rb_str_new2 (r);
2761 static VALUE ruby_guestfs_ping_daemon (VALUE gv)
2764 Data_Get_Struct (gv, guestfs_h, g);
2766 rb_raise (rb_eArgError, "%s: used handle after closing it", "ping_daemon");
2771 r = guestfs_ping_daemon (g);
2773 rb_raise (e_Error, "%s", guestfs_last_error (g));
2778 static VALUE ruby_guestfs_equal (VALUE gv, VALUE file1v, VALUE file2v)
2781 Data_Get_Struct (gv, guestfs_h, g);
2783 rb_raise (rb_eArgError, "%s: used handle after closing it", "equal");
2785 const char *file1 = StringValueCStr (file1v);
2787 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2789 const char *file2 = StringValueCStr (file2v);
2791 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2796 r = guestfs_equal (g, file1, file2);
2798 rb_raise (e_Error, "%s", guestfs_last_error (g));
2803 static VALUE ruby_guestfs_strings (VALUE gv, VALUE pathv)
2806 Data_Get_Struct (gv, guestfs_h, g);
2808 rb_raise (rb_eArgError, "%s: used handle after closing it", "strings");
2810 const char *path = StringValueCStr (pathv);
2812 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2817 r = guestfs_strings (g, path);
2819 rb_raise (e_Error, "%s", guestfs_last_error (g));
2822 for (i = 0; r[i] != NULL; ++i) len++;
2823 VALUE rv = rb_ary_new2 (len);
2824 for (i = 0; r[i] != NULL; ++i) {
2825 rb_ary_push (rv, rb_str_new2 (r[i]));
2832 static VALUE ruby_guestfs_strings_e (VALUE gv, VALUE encodingv, VALUE pathv)
2835 Data_Get_Struct (gv, guestfs_h, g);
2837 rb_raise (rb_eArgError, "%s: used handle after closing it", "strings_e");
2839 const char *encoding = StringValueCStr (encodingv);
2841 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2842 "encoding", "strings_e");
2843 const char *path = StringValueCStr (pathv);
2845 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2846 "path", "strings_e");
2850 r = guestfs_strings_e (g, encoding, path);
2852 rb_raise (e_Error, "%s", guestfs_last_error (g));
2855 for (i = 0; r[i] != NULL; ++i) len++;
2856 VALUE rv = rb_ary_new2 (len);
2857 for (i = 0; r[i] != NULL; ++i) {
2858 rb_ary_push (rv, rb_str_new2 (r[i]));
2865 static VALUE ruby_guestfs_hexdump (VALUE gv, VALUE pathv)
2868 Data_Get_Struct (gv, guestfs_h, g);
2870 rb_raise (rb_eArgError, "%s: used handle after closing it", "hexdump");
2872 const char *path = StringValueCStr (pathv);
2874 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2879 r = guestfs_hexdump (g, path);
2881 rb_raise (e_Error, "%s", guestfs_last_error (g));
2883 VALUE rv = rb_str_new2 (r);
2888 static VALUE ruby_guestfs_zerofree (VALUE gv, VALUE devicev)
2891 Data_Get_Struct (gv, guestfs_h, g);
2893 rb_raise (rb_eArgError, "%s: used handle after closing it", "zerofree");
2895 const char *device = StringValueCStr (devicev);
2897 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2898 "device", "zerofree");
2902 r = guestfs_zerofree (g, device);
2904 rb_raise (e_Error, "%s", guestfs_last_error (g));
2909 static VALUE ruby_guestfs_pvresize (VALUE gv, VALUE devicev)
2912 Data_Get_Struct (gv, guestfs_h, g);
2914 rb_raise (rb_eArgError, "%s: used handle after closing it", "pvresize");
2916 const char *device = StringValueCStr (devicev);
2918 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2919 "device", "pvresize");
2923 r = guestfs_pvresize (g, device);
2925 rb_raise (e_Error, "%s", guestfs_last_error (g));
2930 static VALUE ruby_guestfs_sfdisk_N (VALUE gv, VALUE devicev, VALUE nv, VALUE cylsv, VALUE headsv, VALUE sectorsv, VALUE linev)
2933 Data_Get_Struct (gv, guestfs_h, g);
2935 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_N");
2937 const char *device = StringValueCStr (devicev);
2939 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2940 "device", "sfdisk_N");
2941 int n = NUM2INT (nv);
2942 int cyls = NUM2INT (cylsv);
2943 int heads = NUM2INT (headsv);
2944 int sectors = NUM2INT (sectorsv);
2945 const char *line = StringValueCStr (linev);
2947 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2948 "line", "sfdisk_N");
2952 r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
2954 rb_raise (e_Error, "%s", guestfs_last_error (g));
2959 static VALUE ruby_guestfs_sfdisk_l (VALUE gv, VALUE devicev)
2962 Data_Get_Struct (gv, guestfs_h, g);
2964 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_l");
2966 const char *device = StringValueCStr (devicev);
2968 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2969 "device", "sfdisk_l");
2973 r = guestfs_sfdisk_l (g, device);
2975 rb_raise (e_Error, "%s", guestfs_last_error (g));
2977 VALUE rv = rb_str_new2 (r);
2982 static VALUE ruby_guestfs_sfdisk_kernel_geometry (VALUE gv, VALUE devicev)
2985 Data_Get_Struct (gv, guestfs_h, g);
2987 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_kernel_geometry");
2989 const char *device = StringValueCStr (devicev);
2991 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
2992 "device", "sfdisk_kernel_geometry");
2996 r = guestfs_sfdisk_kernel_geometry (g, device);
2998 rb_raise (e_Error, "%s", guestfs_last_error (g));
3000 VALUE rv = rb_str_new2 (r);
3005 static VALUE ruby_guestfs_sfdisk_disk_geometry (VALUE gv, VALUE devicev)
3008 Data_Get_Struct (gv, guestfs_h, g);
3010 rb_raise (rb_eArgError, "%s: used handle after closing it", "sfdisk_disk_geometry");
3012 const char *device = StringValueCStr (devicev);
3014 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3015 "device", "sfdisk_disk_geometry");
3019 r = guestfs_sfdisk_disk_geometry (g, device);
3021 rb_raise (e_Error, "%s", guestfs_last_error (g));
3023 VALUE rv = rb_str_new2 (r);
3028 static VALUE ruby_guestfs_vg_activate_all (VALUE gv, VALUE activatev)
3031 Data_Get_Struct (gv, guestfs_h, g);
3033 rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate_all");
3035 int activate = NUM2INT (activatev);
3039 r = guestfs_vg_activate_all (g, activate);
3041 rb_raise (e_Error, "%s", guestfs_last_error (g));
3046 static VALUE ruby_guestfs_vg_activate (VALUE gv, VALUE activatev, VALUE volgroupsv)
3049 Data_Get_Struct (gv, guestfs_h, g);
3051 rb_raise (rb_eArgError, "%s: used handle after closing it", "vg_activate");
3053 int activate = NUM2INT (activatev);
3056 len = RARRAY_LEN (volgroupsv);
3057 volgroups = guestfs_safe_malloc (g, sizeof (char *) * (len+1));
3058 for (i = 0; i < len; ++i) {
3059 VALUE v = rb_ary_entry (volgroupsv, i);
3060 volgroups[i] = StringValueCStr (v);
3062 volgroups[len] = NULL;
3067 r = guestfs_vg_activate (g, activate, volgroups);
3070 rb_raise (e_Error, "%s", guestfs_last_error (g));
3075 static VALUE ruby_guestfs_lvresize (VALUE gv, VALUE devicev, VALUE mbytesv)
3078 Data_Get_Struct (gv, guestfs_h, g);
3080 rb_raise (rb_eArgError, "%s: used handle after closing it", "lvresize");
3082 const char *device = StringValueCStr (devicev);
3084 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3085 "device", "lvresize");
3086 int mbytes = NUM2INT (mbytesv);
3090 r = guestfs_lvresize (g, device, mbytes);
3092 rb_raise (e_Error, "%s", guestfs_last_error (g));
3097 static VALUE ruby_guestfs_resize2fs (VALUE gv, VALUE devicev)
3100 Data_Get_Struct (gv, guestfs_h, g);
3102 rb_raise (rb_eArgError, "%s: used handle after closing it", "resize2fs");
3104 const char *device = StringValueCStr (devicev);
3106 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3107 "device", "resize2fs");
3111 r = guestfs_resize2fs (g, device);
3113 rb_raise (e_Error, "%s", guestfs_last_error (g));
3118 static VALUE ruby_guestfs_find (VALUE gv, VALUE directoryv)
3121 Data_Get_Struct (gv, guestfs_h, g);
3123 rb_raise (rb_eArgError, "%s: used handle after closing it", "find");
3125 const char *directory = StringValueCStr (directoryv);
3127 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3128 "directory", "find");
3132 r = guestfs_find (g, directory);
3134 rb_raise (e_Error, "%s", guestfs_last_error (g));
3137 for (i = 0; r[i] != NULL; ++i) len++;
3138 VALUE rv = rb_ary_new2 (len);
3139 for (i = 0; r[i] != NULL; ++i) {
3140 rb_ary_push (rv, rb_str_new2 (r[i]));
3147 static VALUE ruby_guestfs_e2fsck_f (VALUE gv, VALUE devicev)
3150 Data_Get_Struct (gv, guestfs_h, g);
3152 rb_raise (rb_eArgError, "%s: used handle after closing it", "e2fsck_f");
3154 const char *device = StringValueCStr (devicev);
3156 rb_raise (rb_eTypeError, "expected string for parameter %s of %s",
3157 "device", "e2fsck_f");
3161 r = guestfs_e2fsck_f (g, device);
3163 rb_raise (e_Error, "%s", guestfs_last_error (g));
3168 /* Initialize the module. */
3169 void Init__guestfs ()
3171 m_guestfs = rb_define_module ("Guestfs");
3172 c_guestfs = rb_define_class_under (m_guestfs, "Guestfs", rb_cObject);
3173 e_Error = rb_define_class_under (m_guestfs, "Error", rb_eStandardError);
3175 rb_define_module_function (m_guestfs, "create", ruby_guestfs_create, 0);
3176 rb_define_method (c_guestfs, "close", ruby_guestfs_close, 0);
3178 rb_define_method (c_guestfs, "launch",
3179 ruby_guestfs_launch, 0);
3180 rb_define_method (c_guestfs, "wait_ready",
3181 ruby_guestfs_wait_ready, 0);
3182 rb_define_method (c_guestfs, "kill_subprocess",
3183 ruby_guestfs_kill_subprocess, 0);
3184 rb_define_method (c_guestfs, "add_drive",
3185 ruby_guestfs_add_drive, 1);
3186 rb_define_method (c_guestfs, "add_cdrom",
3187 ruby_guestfs_add_cdrom, 1);
3188 rb_define_method (c_guestfs, "config",
3189 ruby_guestfs_config, 2);
3190 rb_define_method (c_guestfs, "set_qemu",
3191 ruby_guestfs_set_qemu, 1);
3192 rb_define_method (c_guestfs, "get_qemu",
3193 ruby_guestfs_get_qemu, 0);
3194 rb_define_method (c_guestfs, "set_path",
3195 ruby_guestfs_set_path, 1);
3196 rb_define_method (c_guestfs, "get_path",
3197 ruby_guestfs_get_path, 0);
3198 rb_define_method (c_guestfs, "set_append",
3199 ruby_guestfs_set_append, 1);
3200 rb_define_method (c_guestfs, "get_append",
3201 ruby_guestfs_get_append, 0);
3202 rb_define_method (c_guestfs, "set_autosync",
3203 ruby_guestfs_set_autosync, 1);
3204 rb_define_method (c_guestfs, "get_autosync",
3205 ruby_guestfs_get_autosync, 0);
3206 rb_define_method (c_guestfs, "set_verbose",
3207 ruby_guestfs_set_verbose, 1);
3208 rb_define_method (c_guestfs, "get_verbose",
3209 ruby_guestfs_get_verbose, 0);
3210 rb_define_method (c_guestfs, "is_ready",
3211 ruby_guestfs_is_ready, 0);
3212 rb_define_method (c_guestfs, "is_config",
3213 ruby_guestfs_is_config, 0);
3214 rb_define_method (c_guestfs, "is_launching",
3215 ruby_guestfs_is_launching, 0);
3216 rb_define_method (c_guestfs, "is_busy",
3217 ruby_guestfs_is_busy, 0);
3218 rb_define_method (c_guestfs, "get_state",
3219 ruby_guestfs_get_state, 0);
3220 rb_define_method (c_guestfs, "set_busy",
3221 ruby_guestfs_set_busy, 0);
3222 rb_define_method (c_guestfs, "set_ready",
3223 ruby_guestfs_set_ready, 0);
3224 rb_define_method (c_guestfs, "end_busy",
3225 ruby_guestfs_end_busy, 0);
3226 rb_define_method (c_guestfs, "mount",
3227 ruby_guestfs_mount, 2);
3228 rb_define_method (c_guestfs, "sync",
3229 ruby_guestfs_sync, 0);
3230 rb_define_method (c_guestfs, "touch",
3231 ruby_guestfs_touch, 1);
3232 rb_define_method (c_guestfs, "cat",
3233 ruby_guestfs_cat, 1);
3234 rb_define_method (c_guestfs, "ll",
3235 ruby_guestfs_ll, 1);
3236 rb_define_method (c_guestfs, "ls",
3237 ruby_guestfs_ls, 1);
3238 rb_define_method (c_guestfs, "list_devices",
3239 ruby_guestfs_list_devices, 0);
3240 rb_define_method (c_guestfs, "list_partitions",
3241 ruby_guestfs_list_partitions, 0);
3242 rb_define_method (c_guestfs, "pvs",
3243 ruby_guestfs_pvs, 0);
3244 rb_define_method (c_guestfs, "vgs",
3245 ruby_guestfs_vgs, 0);
3246 rb_define_method (c_guestfs, "lvs",
3247 ruby_guestfs_lvs, 0);
3248 rb_define_method (c_guestfs, "pvs_full",
3249 ruby_guestfs_pvs_full, 0);
3250 rb_define_method (c_guestfs, "vgs_full",
3251 ruby_guestfs_vgs_full, 0);
3252 rb_define_method (c_guestfs, "lvs_full",
3253 ruby_guestfs_lvs_full, 0);
3254 rb_define_method (c_guestfs, "read_lines",
3255 ruby_guestfs_read_lines, 1);
3256 rb_define_method (c_guestfs, "aug_init",
3257 ruby_guestfs_aug_init, 2);
3258 rb_define_method (c_guestfs, "aug_close",
3259 ruby_guestfs_aug_close, 0);
3260 rb_define_method (c_guestfs, "aug_defvar",
3261 ruby_guestfs_aug_defvar, 2);
3262 rb_define_method (c_guestfs, "aug_defnode",
3263 ruby_guestfs_aug_defnode, 3);
3264 rb_define_method (c_guestfs, "aug_get",
3265 ruby_guestfs_aug_get, 1);
3266 rb_define_method (c_guestfs, "aug_set",
3267 ruby_guestfs_aug_set, 2);
3268 rb_define_method (c_guestfs, "aug_insert",
3269 ruby_guestfs_aug_insert, 3);
3270 rb_define_method (c_guestfs, "aug_rm",
3271 ruby_guestfs_aug_rm, 1);
3272 rb_define_method (c_guestfs, "aug_mv",
3273 ruby_guestfs_aug_mv, 2);
3274 rb_define_method (c_guestfs, "aug_match",
3275 ruby_guestfs_aug_match, 1);
3276 rb_define_method (c_guestfs, "aug_save",
3277 ruby_guestfs_aug_save, 0);
3278 rb_define_method (c_guestfs, "aug_load",
3279 ruby_guestfs_aug_load, 0);
3280 rb_define_method (c_guestfs, "aug_ls",
3281 ruby_guestfs_aug_ls, 1);
3282 rb_define_method (c_guestfs, "rm",
3283 ruby_guestfs_rm, 1);
3284 rb_define_method (c_guestfs, "rmdir",
3285 ruby_guestfs_rmdir, 1);
3286 rb_define_method (c_guestfs, "rm_rf",
3287 ruby_guestfs_rm_rf, 1);
3288 rb_define_method (c_guestfs, "mkdir",
3289 ruby_guestfs_mkdir, 1);
3290 rb_define_method (c_guestfs, "mkdir_p",
3291 ruby_guestfs_mkdir_p, 1);
3292 rb_define_method (c_guestfs, "chmod",
3293 ruby_guestfs_chmod, 2);
3294 rb_define_method (c_guestfs, "chown",
3295 ruby_guestfs_chown, 3);
3296 rb_define_method (c_guestfs, "exists",
3297 ruby_guestfs_exists, 1);
3298 rb_define_method (c_guestfs, "is_file",
3299 ruby_guestfs_is_file, 1);
3300 rb_define_method (c_guestfs, "is_dir",
3301 ruby_guestfs_is_dir, 1);
3302 rb_define_method (c_guestfs, "pvcreate",
3303 ruby_guestfs_pvcreate, 1);
3304 rb_define_method (c_guestfs, "vgcreate",
3305 ruby_guestfs_vgcreate, 2);
3306 rb_define_method (c_guestfs, "lvcreate",
3307 ruby_guestfs_lvcreate, 3);
3308 rb_define_method (c_guestfs, "mkfs",
3309 ruby_guestfs_mkfs, 2);
3310 rb_define_method (c_guestfs, "sfdisk",
3311 ruby_guestfs_sfdisk, 5);
3312 rb_define_method (c_guestfs, "write_file",
3313 ruby_guestfs_write_file, 3);
3314 rb_define_method (c_guestfs, "umount",
3315 ruby_guestfs_umount, 1);
3316 rb_define_method (c_guestfs, "mounts",
3317 ruby_guestfs_mounts, 0);
3318 rb_define_method (c_guestfs, "umount_all",
3319 ruby_guestfs_umount_all, 0);
3320 rb_define_method (c_guestfs, "lvm_remove_all",
3321 ruby_guestfs_lvm_remove_all, 0);
3322 rb_define_method (c_guestfs, "file",
3323 ruby_guestfs_file, 1);
3324 rb_define_method (c_guestfs, "command",
3325 ruby_guestfs_command, 1);
3326 rb_define_method (c_guestfs, "command_lines",
3327 ruby_guestfs_command_lines, 1);
3328 rb_define_method (c_guestfs, "stat",
3329 ruby_guestfs_stat, 1);
3330 rb_define_method (c_guestfs, "lstat",
3331 ruby_guestfs_lstat, 1);
3332 rb_define_method (c_guestfs, "statvfs",
3333 ruby_guestfs_statvfs, 1);
3334 rb_define_method (c_guestfs, "tune2fs_l",
3335 ruby_guestfs_tune2fs_l, 1);
3336 rb_define_method (c_guestfs, "blockdev_setro",
3337 ruby_guestfs_blockdev_setro, 1);
3338 rb_define_method (c_guestfs, "blockdev_setrw",
3339 ruby_guestfs_blockdev_setrw, 1);
3340 rb_define_method (c_guestfs, "blockdev_getro",
3341 ruby_guestfs_blockdev_getro, 1);
3342 rb_define_method (c_guestfs, "blockdev_getss",
3343 ruby_guestfs_blockdev_getss, 1);
3344 rb_define_method (c_guestfs, "blockdev_getbsz",
3345 ruby_guestfs_blockdev_getbsz, 1);
3346 rb_define_method (c_guestfs, "blockdev_setbsz",
3347 ruby_guestfs_blockdev_setbsz, 2);
3348 rb_define_method (c_guestfs, "blockdev_getsz",
3349 ruby_guestfs_blockdev_getsz, 1);
3350 rb_define_method (c_guestfs, "blockdev_getsize64",
3351 ruby_guestfs_blockdev_getsize64, 1);
3352 rb_define_method (c_guestfs, "blockdev_flushbufs",
3353 ruby_guestfs_blockdev_flushbufs, 1);
3354 rb_define_method (c_guestfs, "blockdev_rereadpt",
3355 ruby_guestfs_blockdev_rereadpt, 1);
3356 rb_define_method (c_guestfs, "upload",
3357 ruby_guestfs_upload, 2);
3358 rb_define_method (c_guestfs, "download",
3359 ruby_guestfs_download, 2);
3360 rb_define_method (c_guestfs, "checksum",
3361 ruby_guestfs_checksum, 2);
3362 rb_define_method (c_guestfs, "tar_in",
3363 ruby_guestfs_tar_in, 2);
3364 rb_define_method (c_guestfs, "tar_out",
3365 ruby_guestfs_tar_out, 2);
3366 rb_define_method (c_guestfs, "tgz_in",
3367 ruby_guestfs_tgz_in, 2);
3368 rb_define_method (c_guestfs, "tgz_out",
3369 ruby_guestfs_tgz_out, 2);
3370 rb_define_method (c_guestfs, "mount_ro",
3371 ruby_guestfs_mount_ro, 2);
3372 rb_define_method (c_guestfs, "mount_options",
3373 ruby_guestfs_mount_options, 3);
3374 rb_define_method (c_guestfs, "mount_vfs",
3375 ruby_guestfs_mount_vfs, 4);
3376 rb_define_method (c_guestfs, "debug",
3377 ruby_guestfs_debug, 2);
3378 rb_define_method (c_guestfs, "lvremove",
3379 ruby_guestfs_lvremove, 1);
3380 rb_define_method (c_guestfs, "vgremove",
3381 ruby_guestfs_vgremove, 1);
3382 rb_define_method (c_guestfs, "pvremove",
3383 ruby_guestfs_pvremove, 1);
3384 rb_define_method (c_guestfs, "set_e2label",
3385 ruby_guestfs_set_e2label, 2);
3386 rb_define_method (c_guestfs, "get_e2label",
3387 ruby_guestfs_get_e2label, 1);
3388 rb_define_method (c_guestfs, "set_e2uuid",
3389 ruby_guestfs_set_e2uuid, 2);
3390 rb_define_method (c_guestfs, "get_e2uuid",
3391 ruby_guestfs_get_e2uuid, 1);
3392 rb_define_method (c_guestfs, "fsck",
3393 ruby_guestfs_fsck, 2);
3394 rb_define_method (c_guestfs, "zero",
3395 ruby_guestfs_zero, 1);
3396 rb_define_method (c_guestfs, "grub_install",
3397 ruby_guestfs_grub_install, 2);
3398 rb_define_method (c_guestfs, "cp",
3399 ruby_guestfs_cp, 2);
3400 rb_define_method (c_guestfs, "cp_a",
3401 ruby_guestfs_cp_a, 2);
3402 rb_define_method (c_guestfs, "mv",
3403 ruby_guestfs_mv, 2);
3404 rb_define_method (c_guestfs, "drop_caches",
3405 ruby_guestfs_drop_caches, 1);
3406 rb_define_method (c_guestfs, "dmesg",
3407 ruby_guestfs_dmesg, 0);
3408 rb_define_method (c_guestfs, "ping_daemon",
3409 ruby_guestfs_ping_daemon, 0);
3410 rb_define_method (c_guestfs, "equal",
3411 ruby_guestfs_equal, 2);
3412 rb_define_method (c_guestfs, "strings",
3413 ruby_guestfs_strings, 1);
3414 rb_define_method (c_guestfs, "strings_e",
3415 ruby_guestfs_strings_e, 2);
3416 rb_define_method (c_guestfs, "hexdump",
3417 ruby_guestfs_hexdump, 1);
3418 rb_define_method (c_guestfs, "zerofree",
3419 ruby_guestfs_zerofree, 1);
3420 rb_define_method (c_guestfs, "pvresize",
3421 ruby_guestfs_pvresize, 1);
3422 rb_define_method (c_guestfs, "sfdisk_N",
3423 ruby_guestfs_sfdisk_N, 6);
3424 rb_define_method (c_guestfs, "sfdisk_l",
3425 ruby_guestfs_sfdisk_l, 1);
3426 rb_define_method (c_guestfs, "sfdisk_kernel_geometry",
3427 ruby_guestfs_sfdisk_kernel_geometry, 1);
3428 rb_define_method (c_guestfs, "sfdisk_disk_geometry",
3429 ruby_guestfs_sfdisk_disk_geometry, 1);
3430 rb_define_method (c_guestfs, "vg_activate_all",
3431 ruby_guestfs_vg_activate_all, 1);
3432 rb_define_method (c_guestfs, "vg_activate",
3433 ruby_guestfs_vg_activate, 2);
3434 rb_define_method (c_guestfs, "lvresize",
3435 ruby_guestfs_lvresize, 2);
3436 rb_define_method (c_guestfs, "resize2fs",
3437 ruby_guestfs_resize2fs, 1);
3438 rb_define_method (c_guestfs, "find",
3439 ruby_guestfs_find, 1);
3440 rb_define_method (c_guestfs, "e2fsck_f",
3441 ruby_guestfs_e2fsck_f, 1);