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
26 #include <caml/config.h>
27 #include <caml/alloc.h>
28 #include <caml/callback.h>
29 #include <caml/fail.h>
30 #include <caml/memory.h>
31 #include <caml/mlvalues.h>
32 #include <caml/signals.h>
36 #include "guestfs_c.h"
38 /* Copy a hashtable of string pairs into an assoc-list. We return
39 * the list in reverse order, but hashtables aren't supposed to be
43 copy_table (char * const * argv)
46 CAMLlocal5 (rv, pairv, kv, vv, cons);
50 for (i = 0; argv[i] != NULL; i += 2) {
51 kv = caml_copy_string (argv[i]);
52 vv = caml_copy_string (argv[i+1]);
53 pairv = caml_alloc (2, 0);
54 Store_field (pairv, 0, kv);
55 Store_field (pairv, 1, vv);
56 cons = caml_alloc (2, 0);
57 Store_field (cons, 1, rv);
59 Store_field (cons, 0, pairv);
66 copy_lvm_pv (const struct guestfs_lvm_pv *pv)
71 rv = caml_alloc (14, 0);
72 v = caml_copy_string (pv->pv_name);
73 Store_field (rv, 0, v);
74 v = caml_alloc_string (32);
75 memcpy (String_val (v), pv->pv_uuid, 32);
76 Store_field (rv, 1, v);
77 v = caml_copy_string (pv->pv_fmt);
78 Store_field (rv, 2, v);
79 v = caml_copy_int64 (pv->pv_size);
80 Store_field (rv, 3, v);
81 v = caml_copy_int64 (pv->dev_size);
82 Store_field (rv, 4, v);
83 v = caml_copy_int64 (pv->pv_free);
84 Store_field (rv, 5, v);
85 v = caml_copy_int64 (pv->pv_used);
86 Store_field (rv, 6, v);
87 v = caml_copy_string (pv->pv_attr);
88 Store_field (rv, 7, v);
89 v = caml_copy_int64 (pv->pv_pe_count);
90 Store_field (rv, 8, v);
91 v = caml_copy_int64 (pv->pv_pe_alloc_count);
92 Store_field (rv, 9, v);
93 v = caml_copy_string (pv->pv_tags);
94 Store_field (rv, 10, v);
95 v = caml_copy_int64 (pv->pe_start);
96 Store_field (rv, 11, v);
97 v = caml_copy_int64 (pv->pv_mda_count);
98 Store_field (rv, 12, v);
99 v = caml_copy_int64 (pv->pv_mda_free);
100 Store_field (rv, 13, v);
104 static CAMLprim value
105 copy_lvm_pv_list (const struct guestfs_lvm_pv_list *pvs)
112 CAMLreturn (Atom (0));
114 rv = caml_alloc (pvs->len, 0);
115 for (i = 0; i < pvs->len; ++i) {
116 v = copy_lvm_pv (&pvs->val[i]);
117 caml_modify (&Field (rv, i), v);
123 static CAMLprim value
124 copy_lvm_vg (const struct guestfs_lvm_vg *vg)
129 rv = caml_alloc (19, 0);
130 v = caml_copy_string (vg->vg_name);
131 Store_field (rv, 0, v);
132 v = caml_alloc_string (32);
133 memcpy (String_val (v), vg->vg_uuid, 32);
134 Store_field (rv, 1, v);
135 v = caml_copy_string (vg->vg_fmt);
136 Store_field (rv, 2, v);
137 v = caml_copy_string (vg->vg_attr);
138 Store_field (rv, 3, v);
139 v = caml_copy_int64 (vg->vg_size);
140 Store_field (rv, 4, v);
141 v = caml_copy_int64 (vg->vg_free);
142 Store_field (rv, 5, v);
143 v = caml_copy_string (vg->vg_sysid);
144 Store_field (rv, 6, v);
145 v = caml_copy_int64 (vg->vg_extent_size);
146 Store_field (rv, 7, v);
147 v = caml_copy_int64 (vg->vg_extent_count);
148 Store_field (rv, 8, v);
149 v = caml_copy_int64 (vg->vg_free_count);
150 Store_field (rv, 9, v);
151 v = caml_copy_int64 (vg->max_lv);
152 Store_field (rv, 10, v);
153 v = caml_copy_int64 (vg->max_pv);
154 Store_field (rv, 11, v);
155 v = caml_copy_int64 (vg->pv_count);
156 Store_field (rv, 12, v);
157 v = caml_copy_int64 (vg->lv_count);
158 Store_field (rv, 13, v);
159 v = caml_copy_int64 (vg->snap_count);
160 Store_field (rv, 14, v);
161 v = caml_copy_int64 (vg->vg_seqno);
162 Store_field (rv, 15, v);
163 v = caml_copy_string (vg->vg_tags);
164 Store_field (rv, 16, v);
165 v = caml_copy_int64 (vg->vg_mda_count);
166 Store_field (rv, 17, v);
167 v = caml_copy_int64 (vg->vg_mda_free);
168 Store_field (rv, 18, v);
172 static CAMLprim value
173 copy_lvm_vg_list (const struct guestfs_lvm_vg_list *vgs)
180 CAMLreturn (Atom (0));
182 rv = caml_alloc (vgs->len, 0);
183 for (i = 0; i < vgs->len; ++i) {
184 v = copy_lvm_vg (&vgs->val[i]);
185 caml_modify (&Field (rv, i), v);
191 static CAMLprim value
192 copy_lvm_lv (const struct guestfs_lvm_lv *lv)
195 CAMLlocal3 (rv, v, v2);
197 rv = caml_alloc (16, 0);
198 v = caml_copy_string (lv->lv_name);
199 Store_field (rv, 0, v);
200 v = caml_alloc_string (32);
201 memcpy (String_val (v), lv->lv_uuid, 32);
202 Store_field (rv, 1, v);
203 v = caml_copy_string (lv->lv_attr);
204 Store_field (rv, 2, v);
205 v = caml_copy_int64 (lv->lv_major);
206 Store_field (rv, 3, v);
207 v = caml_copy_int64 (lv->lv_minor);
208 Store_field (rv, 4, v);
209 v = caml_copy_int64 (lv->lv_kernel_major);
210 Store_field (rv, 5, v);
211 v = caml_copy_int64 (lv->lv_kernel_minor);
212 Store_field (rv, 6, v);
213 v = caml_copy_int64 (lv->lv_size);
214 Store_field (rv, 7, v);
215 v = caml_copy_int64 (lv->seg_count);
216 Store_field (rv, 8, v);
217 v = caml_copy_string (lv->origin);
218 Store_field (rv, 9, v);
219 if (lv->snap_percent >= 0) { /* Some snap_percent */
220 v2 = caml_copy_double (lv->snap_percent);
221 v = caml_alloc (1, 0);
222 Store_field (v, 0, v2);
225 Store_field (rv, 10, v);
226 if (lv->copy_percent >= 0) { /* Some copy_percent */
227 v2 = caml_copy_double (lv->copy_percent);
228 v = caml_alloc (1, 0);
229 Store_field (v, 0, v2);
232 Store_field (rv, 11, v);
233 v = caml_copy_string (lv->move_pv);
234 Store_field (rv, 12, v);
235 v = caml_copy_string (lv->lv_tags);
236 Store_field (rv, 13, v);
237 v = caml_copy_string (lv->mirror_log);
238 Store_field (rv, 14, v);
239 v = caml_copy_string (lv->modules);
240 Store_field (rv, 15, v);
244 static CAMLprim value
245 copy_lvm_lv_list (const struct guestfs_lvm_lv_list *lvs)
252 CAMLreturn (Atom (0));
254 rv = caml_alloc (lvs->len, 0);
255 for (i = 0; i < lvs->len; ++i) {
256 v = copy_lvm_lv (&lvs->val[i]);
257 caml_modify (&Field (rv, i), v);
263 static CAMLprim value
264 copy_stat (const struct guestfs_stat *stat)
269 rv = caml_alloc (13, 0);
270 v = caml_copy_int64 (stat->dev);
271 Store_field (rv, 0, v);
272 v = caml_copy_int64 (stat->ino);
273 Store_field (rv, 1, v);
274 v = caml_copy_int64 (stat->mode);
275 Store_field (rv, 2, v);
276 v = caml_copy_int64 (stat->nlink);
277 Store_field (rv, 3, v);
278 v = caml_copy_int64 (stat->uid);
279 Store_field (rv, 4, v);
280 v = caml_copy_int64 (stat->gid);
281 Store_field (rv, 5, v);
282 v = caml_copy_int64 (stat->rdev);
283 Store_field (rv, 6, v);
284 v = caml_copy_int64 (stat->size);
285 Store_field (rv, 7, v);
286 v = caml_copy_int64 (stat->blksize);
287 Store_field (rv, 8, v);
288 v = caml_copy_int64 (stat->blocks);
289 Store_field (rv, 9, v);
290 v = caml_copy_int64 (stat->atime);
291 Store_field (rv, 10, v);
292 v = caml_copy_int64 (stat->mtime);
293 Store_field (rv, 11, v);
294 v = caml_copy_int64 (stat->ctime);
295 Store_field (rv, 12, v);
299 static CAMLprim value
300 copy_statvfs (const struct guestfs_statvfs *statvfs)
305 rv = caml_alloc (11, 0);
306 v = caml_copy_int64 (statvfs->bsize);
307 Store_field (rv, 0, v);
308 v = caml_copy_int64 (statvfs->frsize);
309 Store_field (rv, 1, v);
310 v = caml_copy_int64 (statvfs->blocks);
311 Store_field (rv, 2, v);
312 v = caml_copy_int64 (statvfs->bfree);
313 Store_field (rv, 3, v);
314 v = caml_copy_int64 (statvfs->bavail);
315 Store_field (rv, 4, v);
316 v = caml_copy_int64 (statvfs->files);
317 Store_field (rv, 5, v);
318 v = caml_copy_int64 (statvfs->ffree);
319 Store_field (rv, 6, v);
320 v = caml_copy_int64 (statvfs->favail);
321 Store_field (rv, 7, v);
322 v = caml_copy_int64 (statvfs->fsid);
323 Store_field (rv, 8, v);
324 v = caml_copy_int64 (statvfs->flag);
325 Store_field (rv, 9, v);
326 v = caml_copy_int64 (statvfs->namemax);
327 Store_field (rv, 10, v);
332 ocaml_guestfs_launch (value gv)
337 guestfs_h *g = Guestfs_val (gv);
339 caml_failwith ("launch: used handle after closing it");
343 caml_enter_blocking_section ();
344 r = guestfs_launch (g);
345 caml_leave_blocking_section ();
347 ocaml_guestfs_raise_error (g, "launch");
354 ocaml_guestfs_wait_ready (value gv)
359 guestfs_h *g = Guestfs_val (gv);
361 caml_failwith ("wait_ready: used handle after closing it");
365 caml_enter_blocking_section ();
366 r = guestfs_wait_ready (g);
367 caml_leave_blocking_section ();
369 ocaml_guestfs_raise_error (g, "wait_ready");
376 ocaml_guestfs_kill_subprocess (value gv)
381 guestfs_h *g = Guestfs_val (gv);
383 caml_failwith ("kill_subprocess: used handle after closing it");
387 caml_enter_blocking_section ();
388 r = guestfs_kill_subprocess (g);
389 caml_leave_blocking_section ();
391 ocaml_guestfs_raise_error (g, "kill_subprocess");
398 ocaml_guestfs_add_drive (value gv, value filenamev)
400 CAMLparam2 (gv, filenamev);
403 guestfs_h *g = Guestfs_val (gv);
405 caml_failwith ("add_drive: used handle after closing it");
407 const char *filename = String_val (filenamev);
410 caml_enter_blocking_section ();
411 r = guestfs_add_drive (g, filename);
412 caml_leave_blocking_section ();
414 ocaml_guestfs_raise_error (g, "add_drive");
421 ocaml_guestfs_add_cdrom (value gv, value filenamev)
423 CAMLparam2 (gv, filenamev);
426 guestfs_h *g = Guestfs_val (gv);
428 caml_failwith ("add_cdrom: used handle after closing it");
430 const char *filename = String_val (filenamev);
433 caml_enter_blocking_section ();
434 r = guestfs_add_cdrom (g, filename);
435 caml_leave_blocking_section ();
437 ocaml_guestfs_raise_error (g, "add_cdrom");
444 ocaml_guestfs_config (value gv, value qemuparamv, value qemuvaluev)
446 CAMLparam3 (gv, qemuparamv, qemuvaluev);
449 guestfs_h *g = Guestfs_val (gv);
451 caml_failwith ("config: used handle after closing it");
453 const char *qemuparam = String_val (qemuparamv);
454 const char *qemuvalue =
455 qemuvaluev != Val_int (0) ? String_val (Field (qemuvaluev, 0)) : NULL;
458 caml_enter_blocking_section ();
459 r = guestfs_config (g, qemuparam, qemuvalue);
460 caml_leave_blocking_section ();
462 ocaml_guestfs_raise_error (g, "config");
469 ocaml_guestfs_set_qemu (value gv, value qemuv)
471 CAMLparam2 (gv, qemuv);
474 guestfs_h *g = Guestfs_val (gv);
476 caml_failwith ("set_qemu: used handle after closing it");
478 const char *qemu = String_val (qemuv);
481 caml_enter_blocking_section ();
482 r = guestfs_set_qemu (g, qemu);
483 caml_leave_blocking_section ();
485 ocaml_guestfs_raise_error (g, "set_qemu");
492 ocaml_guestfs_get_qemu (value gv)
497 guestfs_h *g = Guestfs_val (gv);
499 caml_failwith ("get_qemu: used handle after closing it");
503 caml_enter_blocking_section ();
504 r = guestfs_get_qemu (g);
505 caml_leave_blocking_section ();
507 ocaml_guestfs_raise_error (g, "get_qemu");
509 rv = caml_copy_string (r);
514 ocaml_guestfs_set_path (value gv, value pathv)
516 CAMLparam2 (gv, pathv);
519 guestfs_h *g = Guestfs_val (gv);
521 caml_failwith ("set_path: used handle after closing it");
523 const char *path = String_val (pathv);
526 caml_enter_blocking_section ();
527 r = guestfs_set_path (g, path);
528 caml_leave_blocking_section ();
530 ocaml_guestfs_raise_error (g, "set_path");
537 ocaml_guestfs_get_path (value gv)
542 guestfs_h *g = Guestfs_val (gv);
544 caml_failwith ("get_path: used handle after closing it");
548 caml_enter_blocking_section ();
549 r = guestfs_get_path (g);
550 caml_leave_blocking_section ();
552 ocaml_guestfs_raise_error (g, "get_path");
554 rv = caml_copy_string (r);
559 ocaml_guestfs_set_autosync (value gv, value autosyncv)
561 CAMLparam2 (gv, autosyncv);
564 guestfs_h *g = Guestfs_val (gv);
566 caml_failwith ("set_autosync: used handle after closing it");
568 int autosync = Bool_val (autosyncv);
571 caml_enter_blocking_section ();
572 r = guestfs_set_autosync (g, autosync);
573 caml_leave_blocking_section ();
575 ocaml_guestfs_raise_error (g, "set_autosync");
582 ocaml_guestfs_get_autosync (value gv)
587 guestfs_h *g = Guestfs_val (gv);
589 caml_failwith ("get_autosync: used handle after closing it");
593 caml_enter_blocking_section ();
594 r = guestfs_get_autosync (g);
595 caml_leave_blocking_section ();
597 ocaml_guestfs_raise_error (g, "get_autosync");
604 ocaml_guestfs_set_verbose (value gv, value verbosev)
606 CAMLparam2 (gv, verbosev);
609 guestfs_h *g = Guestfs_val (gv);
611 caml_failwith ("set_verbose: used handle after closing it");
613 int verbose = Bool_val (verbosev);
616 caml_enter_blocking_section ();
617 r = guestfs_set_verbose (g, verbose);
618 caml_leave_blocking_section ();
620 ocaml_guestfs_raise_error (g, "set_verbose");
627 ocaml_guestfs_get_verbose (value gv)
632 guestfs_h *g = Guestfs_val (gv);
634 caml_failwith ("get_verbose: used handle after closing it");
638 caml_enter_blocking_section ();
639 r = guestfs_get_verbose (g);
640 caml_leave_blocking_section ();
642 ocaml_guestfs_raise_error (g, "get_verbose");
649 ocaml_guestfs_is_ready (value gv)
654 guestfs_h *g = Guestfs_val (gv);
656 caml_failwith ("is_ready: used handle after closing it");
660 caml_enter_blocking_section ();
661 r = guestfs_is_ready (g);
662 caml_leave_blocking_section ();
664 ocaml_guestfs_raise_error (g, "is_ready");
671 ocaml_guestfs_is_config (value gv)
676 guestfs_h *g = Guestfs_val (gv);
678 caml_failwith ("is_config: used handle after closing it");
682 caml_enter_blocking_section ();
683 r = guestfs_is_config (g);
684 caml_leave_blocking_section ();
686 ocaml_guestfs_raise_error (g, "is_config");
693 ocaml_guestfs_is_launching (value gv)
698 guestfs_h *g = Guestfs_val (gv);
700 caml_failwith ("is_launching: used handle after closing it");
704 caml_enter_blocking_section ();
705 r = guestfs_is_launching (g);
706 caml_leave_blocking_section ();
708 ocaml_guestfs_raise_error (g, "is_launching");
715 ocaml_guestfs_is_busy (value gv)
720 guestfs_h *g = Guestfs_val (gv);
722 caml_failwith ("is_busy: used handle after closing it");
726 caml_enter_blocking_section ();
727 r = guestfs_is_busy (g);
728 caml_leave_blocking_section ();
730 ocaml_guestfs_raise_error (g, "is_busy");
737 ocaml_guestfs_get_state (value gv)
742 guestfs_h *g = Guestfs_val (gv);
744 caml_failwith ("get_state: used handle after closing it");
748 caml_enter_blocking_section ();
749 r = guestfs_get_state (g);
750 caml_leave_blocking_section ();
752 ocaml_guestfs_raise_error (g, "get_state");
759 ocaml_guestfs_set_busy (value gv)
764 guestfs_h *g = Guestfs_val (gv);
766 caml_failwith ("set_busy: used handle after closing it");
770 caml_enter_blocking_section ();
771 r = guestfs_set_busy (g);
772 caml_leave_blocking_section ();
774 ocaml_guestfs_raise_error (g, "set_busy");
781 ocaml_guestfs_set_ready (value gv)
786 guestfs_h *g = Guestfs_val (gv);
788 caml_failwith ("set_ready: used handle after closing it");
792 caml_enter_blocking_section ();
793 r = guestfs_set_ready (g);
794 caml_leave_blocking_section ();
796 ocaml_guestfs_raise_error (g, "set_ready");
803 ocaml_guestfs_end_busy (value gv)
808 guestfs_h *g = Guestfs_val (gv);
810 caml_failwith ("end_busy: used handle after closing it");
814 caml_enter_blocking_section ();
815 r = guestfs_end_busy (g);
816 caml_leave_blocking_section ();
818 ocaml_guestfs_raise_error (g, "end_busy");
825 ocaml_guestfs_mount (value gv, value devicev, value mountpointv)
827 CAMLparam3 (gv, devicev, mountpointv);
830 guestfs_h *g = Guestfs_val (gv);
832 caml_failwith ("mount: used handle after closing it");
834 const char *device = String_val (devicev);
835 const char *mountpoint = String_val (mountpointv);
838 caml_enter_blocking_section ();
839 r = guestfs_mount (g, device, mountpoint);
840 caml_leave_blocking_section ();
842 ocaml_guestfs_raise_error (g, "mount");
849 ocaml_guestfs_sync (value gv)
854 guestfs_h *g = Guestfs_val (gv);
856 caml_failwith ("sync: used handle after closing it");
860 caml_enter_blocking_section ();
861 r = guestfs_sync (g);
862 caml_leave_blocking_section ();
864 ocaml_guestfs_raise_error (g, "sync");
871 ocaml_guestfs_touch (value gv, value pathv)
873 CAMLparam2 (gv, pathv);
876 guestfs_h *g = Guestfs_val (gv);
878 caml_failwith ("touch: used handle after closing it");
880 const char *path = String_val (pathv);
883 caml_enter_blocking_section ();
884 r = guestfs_touch (g, path);
885 caml_leave_blocking_section ();
887 ocaml_guestfs_raise_error (g, "touch");
894 ocaml_guestfs_cat (value gv, value pathv)
896 CAMLparam2 (gv, pathv);
899 guestfs_h *g = Guestfs_val (gv);
901 caml_failwith ("cat: used handle after closing it");
903 const char *path = String_val (pathv);
906 caml_enter_blocking_section ();
907 r = guestfs_cat (g, path);
908 caml_leave_blocking_section ();
910 ocaml_guestfs_raise_error (g, "cat");
912 rv = caml_copy_string (r);
918 ocaml_guestfs_ll (value gv, value directoryv)
920 CAMLparam2 (gv, directoryv);
923 guestfs_h *g = Guestfs_val (gv);
925 caml_failwith ("ll: used handle after closing it");
927 const char *directory = String_val (directoryv);
930 caml_enter_blocking_section ();
931 r = guestfs_ll (g, directory);
932 caml_leave_blocking_section ();
934 ocaml_guestfs_raise_error (g, "ll");
936 rv = caml_copy_string (r);
942 ocaml_guestfs_ls (value gv, value directoryv)
944 CAMLparam2 (gv, directoryv);
947 guestfs_h *g = Guestfs_val (gv);
949 caml_failwith ("ls: used handle after closing it");
951 const char *directory = String_val (directoryv);
955 caml_enter_blocking_section ();
956 r = guestfs_ls (g, directory);
957 caml_leave_blocking_section ();
959 ocaml_guestfs_raise_error (g, "ls");
961 rv = caml_copy_string_array ((const char **) r);
962 for (i = 0; r[i] != NULL; ++i) free (r[i]);
968 ocaml_guestfs_list_devices (value gv)
973 guestfs_h *g = Guestfs_val (gv);
975 caml_failwith ("list_devices: used handle after closing it");
980 caml_enter_blocking_section ();
981 r = guestfs_list_devices (g);
982 caml_leave_blocking_section ();
984 ocaml_guestfs_raise_error (g, "list_devices");
986 rv = caml_copy_string_array ((const char **) r);
987 for (i = 0; r[i] != NULL; ++i) free (r[i]);
993 ocaml_guestfs_list_partitions (value gv)
998 guestfs_h *g = Guestfs_val (gv);
1000 caml_failwith ("list_partitions: used handle after closing it");
1005 caml_enter_blocking_section ();
1006 r = guestfs_list_partitions (g);
1007 caml_leave_blocking_section ();
1009 ocaml_guestfs_raise_error (g, "list_partitions");
1011 rv = caml_copy_string_array ((const char **) r);
1012 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1018 ocaml_guestfs_pvs (value gv)
1023 guestfs_h *g = Guestfs_val (gv);
1025 caml_failwith ("pvs: used handle after closing it");
1030 caml_enter_blocking_section ();
1031 r = guestfs_pvs (g);
1032 caml_leave_blocking_section ();
1034 ocaml_guestfs_raise_error (g, "pvs");
1036 rv = caml_copy_string_array ((const char **) r);
1037 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1043 ocaml_guestfs_vgs (value gv)
1048 guestfs_h *g = Guestfs_val (gv);
1050 caml_failwith ("vgs: used handle after closing it");
1055 caml_enter_blocking_section ();
1056 r = guestfs_vgs (g);
1057 caml_leave_blocking_section ();
1059 ocaml_guestfs_raise_error (g, "vgs");
1061 rv = caml_copy_string_array ((const char **) r);
1062 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1068 ocaml_guestfs_lvs (value gv)
1073 guestfs_h *g = Guestfs_val (gv);
1075 caml_failwith ("lvs: used handle after closing it");
1080 caml_enter_blocking_section ();
1081 r = guestfs_lvs (g);
1082 caml_leave_blocking_section ();
1084 ocaml_guestfs_raise_error (g, "lvs");
1086 rv = caml_copy_string_array ((const char **) r);
1087 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1093 ocaml_guestfs_pvs_full (value gv)
1098 guestfs_h *g = Guestfs_val (gv);
1100 caml_failwith ("pvs_full: used handle after closing it");
1102 struct guestfs_lvm_pv_list *r;
1104 caml_enter_blocking_section ();
1105 r = guestfs_pvs_full (g);
1106 caml_leave_blocking_section ();
1108 ocaml_guestfs_raise_error (g, "pvs_full");
1110 rv = copy_lvm_pv_list (r);
1111 guestfs_free_lvm_pv_list (r);
1116 ocaml_guestfs_vgs_full (value gv)
1121 guestfs_h *g = Guestfs_val (gv);
1123 caml_failwith ("vgs_full: used handle after closing it");
1125 struct guestfs_lvm_vg_list *r;
1127 caml_enter_blocking_section ();
1128 r = guestfs_vgs_full (g);
1129 caml_leave_blocking_section ();
1131 ocaml_guestfs_raise_error (g, "vgs_full");
1133 rv = copy_lvm_vg_list (r);
1134 guestfs_free_lvm_vg_list (r);
1139 ocaml_guestfs_lvs_full (value gv)
1144 guestfs_h *g = Guestfs_val (gv);
1146 caml_failwith ("lvs_full: used handle after closing it");
1148 struct guestfs_lvm_lv_list *r;
1150 caml_enter_blocking_section ();
1151 r = guestfs_lvs_full (g);
1152 caml_leave_blocking_section ();
1154 ocaml_guestfs_raise_error (g, "lvs_full");
1156 rv = copy_lvm_lv_list (r);
1157 guestfs_free_lvm_lv_list (r);
1162 ocaml_guestfs_read_lines (value gv, value pathv)
1164 CAMLparam2 (gv, pathv);
1167 guestfs_h *g = Guestfs_val (gv);
1169 caml_failwith ("read_lines: used handle after closing it");
1171 const char *path = String_val (pathv);
1175 caml_enter_blocking_section ();
1176 r = guestfs_read_lines (g, path);
1177 caml_leave_blocking_section ();
1179 ocaml_guestfs_raise_error (g, "read_lines");
1181 rv = caml_copy_string_array ((const char **) r);
1182 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1188 ocaml_guestfs_aug_init (value gv, value rootv, value flagsv)
1190 CAMLparam3 (gv, rootv, flagsv);
1193 guestfs_h *g = Guestfs_val (gv);
1195 caml_failwith ("aug_init: used handle after closing it");
1197 const char *root = String_val (rootv);
1198 int flags = Int_val (flagsv);
1201 caml_enter_blocking_section ();
1202 r = guestfs_aug_init (g, root, flags);
1203 caml_leave_blocking_section ();
1205 ocaml_guestfs_raise_error (g, "aug_init");
1212 ocaml_guestfs_aug_close (value gv)
1217 guestfs_h *g = Guestfs_val (gv);
1219 caml_failwith ("aug_close: used handle after closing it");
1223 caml_enter_blocking_section ();
1224 r = guestfs_aug_close (g);
1225 caml_leave_blocking_section ();
1227 ocaml_guestfs_raise_error (g, "aug_close");
1234 ocaml_guestfs_aug_defvar (value gv, value namev, value exprv)
1236 CAMLparam3 (gv, namev, exprv);
1239 guestfs_h *g = Guestfs_val (gv);
1241 caml_failwith ("aug_defvar: used handle after closing it");
1243 const char *name = String_val (namev);
1245 exprv != Val_int (0) ? String_val (Field (exprv, 0)) : NULL;
1248 caml_enter_blocking_section ();
1249 r = guestfs_aug_defvar (g, name, expr);
1250 caml_leave_blocking_section ();
1252 ocaml_guestfs_raise_error (g, "aug_defvar");
1259 ocaml_guestfs_aug_defnode (value gv, value namev, value exprv, value valv)
1261 CAMLparam4 (gv, namev, exprv, valv);
1264 guestfs_h *g = Guestfs_val (gv);
1266 caml_failwith ("aug_defnode: used handle after closing it");
1268 const char *name = String_val (namev);
1269 const char *expr = String_val (exprv);
1270 const char *val = String_val (valv);
1271 struct guestfs_int_bool *r;
1273 caml_enter_blocking_section ();
1274 r = guestfs_aug_defnode (g, name, expr, val);
1275 caml_leave_blocking_section ();
1277 ocaml_guestfs_raise_error (g, "aug_defnode");
1279 rv = caml_alloc (2, 0);
1280 Store_field (rv, 0, Val_int (r->i));
1281 Store_field (rv, 1, Val_bool (r->b));
1282 guestfs_free_int_bool (r);
1287 ocaml_guestfs_aug_get (value gv, value pathv)
1289 CAMLparam2 (gv, pathv);
1292 guestfs_h *g = Guestfs_val (gv);
1294 caml_failwith ("aug_get: used handle after closing it");
1296 const char *path = String_val (pathv);
1299 caml_enter_blocking_section ();
1300 r = guestfs_aug_get (g, path);
1301 caml_leave_blocking_section ();
1303 ocaml_guestfs_raise_error (g, "aug_get");
1305 rv = caml_copy_string (r);
1311 ocaml_guestfs_aug_set (value gv, value pathv, value valv)
1313 CAMLparam3 (gv, pathv, valv);
1316 guestfs_h *g = Guestfs_val (gv);
1318 caml_failwith ("aug_set: used handle after closing it");
1320 const char *path = String_val (pathv);
1321 const char *val = String_val (valv);
1324 caml_enter_blocking_section ();
1325 r = guestfs_aug_set (g, path, val);
1326 caml_leave_blocking_section ();
1328 ocaml_guestfs_raise_error (g, "aug_set");
1335 ocaml_guestfs_aug_insert (value gv, value pathv, value labelv, value beforev)
1337 CAMLparam4 (gv, pathv, labelv, beforev);
1340 guestfs_h *g = Guestfs_val (gv);
1342 caml_failwith ("aug_insert: used handle after closing it");
1344 const char *path = String_val (pathv);
1345 const char *label = String_val (labelv);
1346 int before = Bool_val (beforev);
1349 caml_enter_blocking_section ();
1350 r = guestfs_aug_insert (g, path, label, before);
1351 caml_leave_blocking_section ();
1353 ocaml_guestfs_raise_error (g, "aug_insert");
1360 ocaml_guestfs_aug_rm (value gv, value pathv)
1362 CAMLparam2 (gv, pathv);
1365 guestfs_h *g = Guestfs_val (gv);
1367 caml_failwith ("aug_rm: used handle after closing it");
1369 const char *path = String_val (pathv);
1372 caml_enter_blocking_section ();
1373 r = guestfs_aug_rm (g, path);
1374 caml_leave_blocking_section ();
1376 ocaml_guestfs_raise_error (g, "aug_rm");
1383 ocaml_guestfs_aug_mv (value gv, value srcv, value destv)
1385 CAMLparam3 (gv, srcv, destv);
1388 guestfs_h *g = Guestfs_val (gv);
1390 caml_failwith ("aug_mv: used handle after closing it");
1392 const char *src = String_val (srcv);
1393 const char *dest = String_val (destv);
1396 caml_enter_blocking_section ();
1397 r = guestfs_aug_mv (g, src, dest);
1398 caml_leave_blocking_section ();
1400 ocaml_guestfs_raise_error (g, "aug_mv");
1407 ocaml_guestfs_aug_match (value gv, value pathv)
1409 CAMLparam2 (gv, pathv);
1412 guestfs_h *g = Guestfs_val (gv);
1414 caml_failwith ("aug_match: used handle after closing it");
1416 const char *path = String_val (pathv);
1420 caml_enter_blocking_section ();
1421 r = guestfs_aug_match (g, path);
1422 caml_leave_blocking_section ();
1424 ocaml_guestfs_raise_error (g, "aug_match");
1426 rv = caml_copy_string_array ((const char **) r);
1427 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1433 ocaml_guestfs_aug_save (value gv)
1438 guestfs_h *g = Guestfs_val (gv);
1440 caml_failwith ("aug_save: used handle after closing it");
1444 caml_enter_blocking_section ();
1445 r = guestfs_aug_save (g);
1446 caml_leave_blocking_section ();
1448 ocaml_guestfs_raise_error (g, "aug_save");
1455 ocaml_guestfs_aug_load (value gv)
1460 guestfs_h *g = Guestfs_val (gv);
1462 caml_failwith ("aug_load: used handle after closing it");
1466 caml_enter_blocking_section ();
1467 r = guestfs_aug_load (g);
1468 caml_leave_blocking_section ();
1470 ocaml_guestfs_raise_error (g, "aug_load");
1477 ocaml_guestfs_aug_ls (value gv, value pathv)
1479 CAMLparam2 (gv, pathv);
1482 guestfs_h *g = Guestfs_val (gv);
1484 caml_failwith ("aug_ls: used handle after closing it");
1486 const char *path = String_val (pathv);
1490 caml_enter_blocking_section ();
1491 r = guestfs_aug_ls (g, path);
1492 caml_leave_blocking_section ();
1494 ocaml_guestfs_raise_error (g, "aug_ls");
1496 rv = caml_copy_string_array ((const char **) r);
1497 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1503 ocaml_guestfs_rm (value gv, value pathv)
1505 CAMLparam2 (gv, pathv);
1508 guestfs_h *g = Guestfs_val (gv);
1510 caml_failwith ("rm: used handle after closing it");
1512 const char *path = String_val (pathv);
1515 caml_enter_blocking_section ();
1516 r = guestfs_rm (g, path);
1517 caml_leave_blocking_section ();
1519 ocaml_guestfs_raise_error (g, "rm");
1526 ocaml_guestfs_rmdir (value gv, value pathv)
1528 CAMLparam2 (gv, pathv);
1531 guestfs_h *g = Guestfs_val (gv);
1533 caml_failwith ("rmdir: used handle after closing it");
1535 const char *path = String_val (pathv);
1538 caml_enter_blocking_section ();
1539 r = guestfs_rmdir (g, path);
1540 caml_leave_blocking_section ();
1542 ocaml_guestfs_raise_error (g, "rmdir");
1549 ocaml_guestfs_rm_rf (value gv, value pathv)
1551 CAMLparam2 (gv, pathv);
1554 guestfs_h *g = Guestfs_val (gv);
1556 caml_failwith ("rm_rf: used handle after closing it");
1558 const char *path = String_val (pathv);
1561 caml_enter_blocking_section ();
1562 r = guestfs_rm_rf (g, path);
1563 caml_leave_blocking_section ();
1565 ocaml_guestfs_raise_error (g, "rm_rf");
1572 ocaml_guestfs_mkdir (value gv, value pathv)
1574 CAMLparam2 (gv, pathv);
1577 guestfs_h *g = Guestfs_val (gv);
1579 caml_failwith ("mkdir: used handle after closing it");
1581 const char *path = String_val (pathv);
1584 caml_enter_blocking_section ();
1585 r = guestfs_mkdir (g, path);
1586 caml_leave_blocking_section ();
1588 ocaml_guestfs_raise_error (g, "mkdir");
1595 ocaml_guestfs_mkdir_p (value gv, value pathv)
1597 CAMLparam2 (gv, pathv);
1600 guestfs_h *g = Guestfs_val (gv);
1602 caml_failwith ("mkdir_p: used handle after closing it");
1604 const char *path = String_val (pathv);
1607 caml_enter_blocking_section ();
1608 r = guestfs_mkdir_p (g, path);
1609 caml_leave_blocking_section ();
1611 ocaml_guestfs_raise_error (g, "mkdir_p");
1618 ocaml_guestfs_chmod (value gv, value modev, value pathv)
1620 CAMLparam3 (gv, modev, pathv);
1623 guestfs_h *g = Guestfs_val (gv);
1625 caml_failwith ("chmod: used handle after closing it");
1627 int mode = Int_val (modev);
1628 const char *path = String_val (pathv);
1631 caml_enter_blocking_section ();
1632 r = guestfs_chmod (g, mode, path);
1633 caml_leave_blocking_section ();
1635 ocaml_guestfs_raise_error (g, "chmod");
1642 ocaml_guestfs_chown (value gv, value ownerv, value groupv, value pathv)
1644 CAMLparam4 (gv, ownerv, groupv, pathv);
1647 guestfs_h *g = Guestfs_val (gv);
1649 caml_failwith ("chown: used handle after closing it");
1651 int owner = Int_val (ownerv);
1652 int group = Int_val (groupv);
1653 const char *path = String_val (pathv);
1656 caml_enter_blocking_section ();
1657 r = guestfs_chown (g, owner, group, path);
1658 caml_leave_blocking_section ();
1660 ocaml_guestfs_raise_error (g, "chown");
1667 ocaml_guestfs_exists (value gv, value pathv)
1669 CAMLparam2 (gv, pathv);
1672 guestfs_h *g = Guestfs_val (gv);
1674 caml_failwith ("exists: used handle after closing it");
1676 const char *path = String_val (pathv);
1679 caml_enter_blocking_section ();
1680 r = guestfs_exists (g, path);
1681 caml_leave_blocking_section ();
1683 ocaml_guestfs_raise_error (g, "exists");
1690 ocaml_guestfs_is_file (value gv, value pathv)
1692 CAMLparam2 (gv, pathv);
1695 guestfs_h *g = Guestfs_val (gv);
1697 caml_failwith ("is_file: used handle after closing it");
1699 const char *path = String_val (pathv);
1702 caml_enter_blocking_section ();
1703 r = guestfs_is_file (g, path);
1704 caml_leave_blocking_section ();
1706 ocaml_guestfs_raise_error (g, "is_file");
1713 ocaml_guestfs_is_dir (value gv, value pathv)
1715 CAMLparam2 (gv, pathv);
1718 guestfs_h *g = Guestfs_val (gv);
1720 caml_failwith ("is_dir: used handle after closing it");
1722 const char *path = String_val (pathv);
1725 caml_enter_blocking_section ();
1726 r = guestfs_is_dir (g, path);
1727 caml_leave_blocking_section ();
1729 ocaml_guestfs_raise_error (g, "is_dir");
1736 ocaml_guestfs_pvcreate (value gv, value devicev)
1738 CAMLparam2 (gv, devicev);
1741 guestfs_h *g = Guestfs_val (gv);
1743 caml_failwith ("pvcreate: used handle after closing it");
1745 const char *device = String_val (devicev);
1748 caml_enter_blocking_section ();
1749 r = guestfs_pvcreate (g, device);
1750 caml_leave_blocking_section ();
1752 ocaml_guestfs_raise_error (g, "pvcreate");
1759 ocaml_guestfs_vgcreate (value gv, value volgroupv, value physvolsv)
1761 CAMLparam3 (gv, volgroupv, physvolsv);
1764 guestfs_h *g = Guestfs_val (gv);
1766 caml_failwith ("vgcreate: used handle after closing it");
1768 const char *volgroup = String_val (volgroupv);
1769 char **physvols = ocaml_guestfs_strings_val (g, physvolsv);
1772 caml_enter_blocking_section ();
1773 r = guestfs_vgcreate (g, volgroup, physvols);
1774 caml_leave_blocking_section ();
1775 ocaml_guestfs_free_strings (physvols);
1777 ocaml_guestfs_raise_error (g, "vgcreate");
1784 ocaml_guestfs_lvcreate (value gv, value logvolv, value volgroupv, value mbytesv)
1786 CAMLparam4 (gv, logvolv, volgroupv, mbytesv);
1789 guestfs_h *g = Guestfs_val (gv);
1791 caml_failwith ("lvcreate: used handle after closing it");
1793 const char *logvol = String_val (logvolv);
1794 const char *volgroup = String_val (volgroupv);
1795 int mbytes = Int_val (mbytesv);
1798 caml_enter_blocking_section ();
1799 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1800 caml_leave_blocking_section ();
1802 ocaml_guestfs_raise_error (g, "lvcreate");
1809 ocaml_guestfs_mkfs (value gv, value fstypev, value devicev)
1811 CAMLparam3 (gv, fstypev, devicev);
1814 guestfs_h *g = Guestfs_val (gv);
1816 caml_failwith ("mkfs: used handle after closing it");
1818 const char *fstype = String_val (fstypev);
1819 const char *device = String_val (devicev);
1822 caml_enter_blocking_section ();
1823 r = guestfs_mkfs (g, fstype, device);
1824 caml_leave_blocking_section ();
1826 ocaml_guestfs_raise_error (g, "mkfs");
1833 ocaml_guestfs_sfdisk (value gv, value devicev, value cylsv, value headsv, value sectorsv, value linesv)
1835 CAMLparam5 (gv, devicev, cylsv, headsv, sectorsv);
1836 CAMLxparam1 (linesv);
1839 guestfs_h *g = Guestfs_val (gv);
1841 caml_failwith ("sfdisk: used handle after closing it");
1843 const char *device = String_val (devicev);
1844 int cyls = Int_val (cylsv);
1845 int heads = Int_val (headsv);
1846 int sectors = Int_val (sectorsv);
1847 char **lines = ocaml_guestfs_strings_val (g, linesv);
1850 caml_enter_blocking_section ();
1851 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1852 caml_leave_blocking_section ();
1853 ocaml_guestfs_free_strings (lines);
1855 ocaml_guestfs_raise_error (g, "sfdisk");
1862 ocaml_guestfs_sfdisk_byte (value *argv, int argn)
1864 return ocaml_guestfs_sfdisk (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4]);
1868 ocaml_guestfs_write_file (value gv, value pathv, value contentv, value sizev)
1870 CAMLparam4 (gv, pathv, contentv, sizev);
1873 guestfs_h *g = Guestfs_val (gv);
1875 caml_failwith ("write_file: used handle after closing it");
1877 const char *path = String_val (pathv);
1878 const char *content = String_val (contentv);
1879 int size = Int_val (sizev);
1882 caml_enter_blocking_section ();
1883 r = guestfs_write_file (g, path, content, size);
1884 caml_leave_blocking_section ();
1886 ocaml_guestfs_raise_error (g, "write_file");
1893 ocaml_guestfs_umount (value gv, value pathordevicev)
1895 CAMLparam2 (gv, pathordevicev);
1898 guestfs_h *g = Guestfs_val (gv);
1900 caml_failwith ("umount: used handle after closing it");
1902 const char *pathordevice = String_val (pathordevicev);
1905 caml_enter_blocking_section ();
1906 r = guestfs_umount (g, pathordevice);
1907 caml_leave_blocking_section ();
1909 ocaml_guestfs_raise_error (g, "umount");
1916 ocaml_guestfs_mounts (value gv)
1921 guestfs_h *g = Guestfs_val (gv);
1923 caml_failwith ("mounts: used handle after closing it");
1928 caml_enter_blocking_section ();
1929 r = guestfs_mounts (g);
1930 caml_leave_blocking_section ();
1932 ocaml_guestfs_raise_error (g, "mounts");
1934 rv = caml_copy_string_array ((const char **) r);
1935 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1941 ocaml_guestfs_umount_all (value gv)
1946 guestfs_h *g = Guestfs_val (gv);
1948 caml_failwith ("umount_all: used handle after closing it");
1952 caml_enter_blocking_section ();
1953 r = guestfs_umount_all (g);
1954 caml_leave_blocking_section ();
1956 ocaml_guestfs_raise_error (g, "umount_all");
1963 ocaml_guestfs_lvm_remove_all (value gv)
1968 guestfs_h *g = Guestfs_val (gv);
1970 caml_failwith ("lvm_remove_all: used handle after closing it");
1974 caml_enter_blocking_section ();
1975 r = guestfs_lvm_remove_all (g);
1976 caml_leave_blocking_section ();
1978 ocaml_guestfs_raise_error (g, "lvm_remove_all");
1985 ocaml_guestfs_file (value gv, value pathv)
1987 CAMLparam2 (gv, pathv);
1990 guestfs_h *g = Guestfs_val (gv);
1992 caml_failwith ("file: used handle after closing it");
1994 const char *path = String_val (pathv);
1997 caml_enter_blocking_section ();
1998 r = guestfs_file (g, path);
1999 caml_leave_blocking_section ();
2001 ocaml_guestfs_raise_error (g, "file");
2003 rv = caml_copy_string (r);
2009 ocaml_guestfs_command (value gv, value argumentsv)
2011 CAMLparam2 (gv, argumentsv);
2014 guestfs_h *g = Guestfs_val (gv);
2016 caml_failwith ("command: used handle after closing it");
2018 char **arguments = ocaml_guestfs_strings_val (g, argumentsv);
2021 caml_enter_blocking_section ();
2022 r = guestfs_command (g, arguments);
2023 caml_leave_blocking_section ();
2024 ocaml_guestfs_free_strings (arguments);
2026 ocaml_guestfs_raise_error (g, "command");
2028 rv = caml_copy_string (r);
2034 ocaml_guestfs_command_lines (value gv, value argumentsv)
2036 CAMLparam2 (gv, argumentsv);
2039 guestfs_h *g = Guestfs_val (gv);
2041 caml_failwith ("command_lines: used handle after closing it");
2043 char **arguments = ocaml_guestfs_strings_val (g, argumentsv);
2047 caml_enter_blocking_section ();
2048 r = guestfs_command_lines (g, arguments);
2049 caml_leave_blocking_section ();
2050 ocaml_guestfs_free_strings (arguments);
2052 ocaml_guestfs_raise_error (g, "command_lines");
2054 rv = caml_copy_string_array ((const char **) r);
2055 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2061 ocaml_guestfs_stat (value gv, value pathv)
2063 CAMLparam2 (gv, pathv);
2066 guestfs_h *g = Guestfs_val (gv);
2068 caml_failwith ("stat: used handle after closing it");
2070 const char *path = String_val (pathv);
2071 struct guestfs_stat *r;
2073 caml_enter_blocking_section ();
2074 r = guestfs_stat (g, path);
2075 caml_leave_blocking_section ();
2077 ocaml_guestfs_raise_error (g, "stat");
2085 ocaml_guestfs_lstat (value gv, value pathv)
2087 CAMLparam2 (gv, pathv);
2090 guestfs_h *g = Guestfs_val (gv);
2092 caml_failwith ("lstat: used handle after closing it");
2094 const char *path = String_val (pathv);
2095 struct guestfs_stat *r;
2097 caml_enter_blocking_section ();
2098 r = guestfs_lstat (g, path);
2099 caml_leave_blocking_section ();
2101 ocaml_guestfs_raise_error (g, "lstat");
2109 ocaml_guestfs_statvfs (value gv, value pathv)
2111 CAMLparam2 (gv, pathv);
2114 guestfs_h *g = Guestfs_val (gv);
2116 caml_failwith ("statvfs: used handle after closing it");
2118 const char *path = String_val (pathv);
2119 struct guestfs_statvfs *r;
2121 caml_enter_blocking_section ();
2122 r = guestfs_statvfs (g, path);
2123 caml_leave_blocking_section ();
2125 ocaml_guestfs_raise_error (g, "statvfs");
2127 rv = copy_statvfs (r);
2133 ocaml_guestfs_tune2fs_l (value gv, value devicev)
2135 CAMLparam2 (gv, devicev);
2138 guestfs_h *g = Guestfs_val (gv);
2140 caml_failwith ("tune2fs_l: used handle after closing it");
2142 const char *device = String_val (devicev);
2146 caml_enter_blocking_section ();
2147 r = guestfs_tune2fs_l (g, device);
2148 caml_leave_blocking_section ();
2150 ocaml_guestfs_raise_error (g, "tune2fs_l");
2152 rv = copy_table (r);
2153 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2159 ocaml_guestfs_blockdev_setro (value gv, value devicev)
2161 CAMLparam2 (gv, devicev);
2164 guestfs_h *g = Guestfs_val (gv);
2166 caml_failwith ("blockdev_setro: used handle after closing it");
2168 const char *device = String_val (devicev);
2171 caml_enter_blocking_section ();
2172 r = guestfs_blockdev_setro (g, device);
2173 caml_leave_blocking_section ();
2175 ocaml_guestfs_raise_error (g, "blockdev_setro");
2182 ocaml_guestfs_blockdev_setrw (value gv, value devicev)
2184 CAMLparam2 (gv, devicev);
2187 guestfs_h *g = Guestfs_val (gv);
2189 caml_failwith ("blockdev_setrw: used handle after closing it");
2191 const char *device = String_val (devicev);
2194 caml_enter_blocking_section ();
2195 r = guestfs_blockdev_setrw (g, device);
2196 caml_leave_blocking_section ();
2198 ocaml_guestfs_raise_error (g, "blockdev_setrw");
2205 ocaml_guestfs_blockdev_getro (value gv, value devicev)
2207 CAMLparam2 (gv, devicev);
2210 guestfs_h *g = Guestfs_val (gv);
2212 caml_failwith ("blockdev_getro: used handle after closing it");
2214 const char *device = String_val (devicev);
2217 caml_enter_blocking_section ();
2218 r = guestfs_blockdev_getro (g, device);
2219 caml_leave_blocking_section ();
2221 ocaml_guestfs_raise_error (g, "blockdev_getro");
2228 ocaml_guestfs_blockdev_getss (value gv, value devicev)
2230 CAMLparam2 (gv, devicev);
2233 guestfs_h *g = Guestfs_val (gv);
2235 caml_failwith ("blockdev_getss: used handle after closing it");
2237 const char *device = String_val (devicev);
2240 caml_enter_blocking_section ();
2241 r = guestfs_blockdev_getss (g, device);
2242 caml_leave_blocking_section ();
2244 ocaml_guestfs_raise_error (g, "blockdev_getss");
2251 ocaml_guestfs_blockdev_getbsz (value gv, value devicev)
2253 CAMLparam2 (gv, devicev);
2256 guestfs_h *g = Guestfs_val (gv);
2258 caml_failwith ("blockdev_getbsz: used handle after closing it");
2260 const char *device = String_val (devicev);
2263 caml_enter_blocking_section ();
2264 r = guestfs_blockdev_getbsz (g, device);
2265 caml_leave_blocking_section ();
2267 ocaml_guestfs_raise_error (g, "blockdev_getbsz");
2274 ocaml_guestfs_blockdev_setbsz (value gv, value devicev, value blocksizev)
2276 CAMLparam3 (gv, devicev, blocksizev);
2279 guestfs_h *g = Guestfs_val (gv);
2281 caml_failwith ("blockdev_setbsz: used handle after closing it");
2283 const char *device = String_val (devicev);
2284 int blocksize = Int_val (blocksizev);
2287 caml_enter_blocking_section ();
2288 r = guestfs_blockdev_setbsz (g, device, blocksize);
2289 caml_leave_blocking_section ();
2291 ocaml_guestfs_raise_error (g, "blockdev_setbsz");
2298 ocaml_guestfs_blockdev_getsz (value gv, value devicev)
2300 CAMLparam2 (gv, devicev);
2303 guestfs_h *g = Guestfs_val (gv);
2305 caml_failwith ("blockdev_getsz: used handle after closing it");
2307 const char *device = String_val (devicev);
2310 caml_enter_blocking_section ();
2311 r = guestfs_blockdev_getsz (g, device);
2312 caml_leave_blocking_section ();
2314 ocaml_guestfs_raise_error (g, "blockdev_getsz");
2316 rv = caml_copy_int64 (r);
2321 ocaml_guestfs_blockdev_getsize64 (value gv, value devicev)
2323 CAMLparam2 (gv, devicev);
2326 guestfs_h *g = Guestfs_val (gv);
2328 caml_failwith ("blockdev_getsize64: used handle after closing it");
2330 const char *device = String_val (devicev);
2333 caml_enter_blocking_section ();
2334 r = guestfs_blockdev_getsize64 (g, device);
2335 caml_leave_blocking_section ();
2337 ocaml_guestfs_raise_error (g, "blockdev_getsize64");
2339 rv = caml_copy_int64 (r);
2344 ocaml_guestfs_blockdev_flushbufs (value gv, value devicev)
2346 CAMLparam2 (gv, devicev);
2349 guestfs_h *g = Guestfs_val (gv);
2351 caml_failwith ("blockdev_flushbufs: used handle after closing it");
2353 const char *device = String_val (devicev);
2356 caml_enter_blocking_section ();
2357 r = guestfs_blockdev_flushbufs (g, device);
2358 caml_leave_blocking_section ();
2360 ocaml_guestfs_raise_error (g, "blockdev_flushbufs");
2367 ocaml_guestfs_blockdev_rereadpt (value gv, value devicev)
2369 CAMLparam2 (gv, devicev);
2372 guestfs_h *g = Guestfs_val (gv);
2374 caml_failwith ("blockdev_rereadpt: used handle after closing it");
2376 const char *device = String_val (devicev);
2379 caml_enter_blocking_section ();
2380 r = guestfs_blockdev_rereadpt (g, device);
2381 caml_leave_blocking_section ();
2383 ocaml_guestfs_raise_error (g, "blockdev_rereadpt");
2390 ocaml_guestfs_upload (value gv, value filenamev, value remotefilenamev)
2392 CAMLparam3 (gv, filenamev, remotefilenamev);
2395 guestfs_h *g = Guestfs_val (gv);
2397 caml_failwith ("upload: used handle after closing it");
2399 const char *filename = String_val (filenamev);
2400 const char *remotefilename = String_val (remotefilenamev);
2403 caml_enter_blocking_section ();
2404 r = guestfs_upload (g, filename, remotefilename);
2405 caml_leave_blocking_section ();
2407 ocaml_guestfs_raise_error (g, "upload");
2414 ocaml_guestfs_download (value gv, value remotefilenamev, value filenamev)
2416 CAMLparam3 (gv, remotefilenamev, filenamev);
2419 guestfs_h *g = Guestfs_val (gv);
2421 caml_failwith ("download: used handle after closing it");
2423 const char *remotefilename = String_val (remotefilenamev);
2424 const char *filename = String_val (filenamev);
2427 caml_enter_blocking_section ();
2428 r = guestfs_download (g, remotefilename, filename);
2429 caml_leave_blocking_section ();
2431 ocaml_guestfs_raise_error (g, "download");
2438 ocaml_guestfs_checksum (value gv, value csumtypev, value pathv)
2440 CAMLparam3 (gv, csumtypev, pathv);
2443 guestfs_h *g = Guestfs_val (gv);
2445 caml_failwith ("checksum: used handle after closing it");
2447 const char *csumtype = String_val (csumtypev);
2448 const char *path = String_val (pathv);
2451 caml_enter_blocking_section ();
2452 r = guestfs_checksum (g, csumtype, path);
2453 caml_leave_blocking_section ();
2455 ocaml_guestfs_raise_error (g, "checksum");
2457 rv = caml_copy_string (r);
2463 ocaml_guestfs_tar_in (value gv, value tarfilev, value directoryv)
2465 CAMLparam3 (gv, tarfilev, directoryv);
2468 guestfs_h *g = Guestfs_val (gv);
2470 caml_failwith ("tar_in: used handle after closing it");
2472 const char *tarfile = String_val (tarfilev);
2473 const char *directory = String_val (directoryv);
2476 caml_enter_blocking_section ();
2477 r = guestfs_tar_in (g, tarfile, directory);
2478 caml_leave_blocking_section ();
2480 ocaml_guestfs_raise_error (g, "tar_in");
2487 ocaml_guestfs_tar_out (value gv, value directoryv, value tarfilev)
2489 CAMLparam3 (gv, directoryv, tarfilev);
2492 guestfs_h *g = Guestfs_val (gv);
2494 caml_failwith ("tar_out: used handle after closing it");
2496 const char *directory = String_val (directoryv);
2497 const char *tarfile = String_val (tarfilev);
2500 caml_enter_blocking_section ();
2501 r = guestfs_tar_out (g, directory, tarfile);
2502 caml_leave_blocking_section ();
2504 ocaml_guestfs_raise_error (g, "tar_out");
2511 ocaml_guestfs_tgz_in (value gv, value tarballv, value directoryv)
2513 CAMLparam3 (gv, tarballv, directoryv);
2516 guestfs_h *g = Guestfs_val (gv);
2518 caml_failwith ("tgz_in: used handle after closing it");
2520 const char *tarball = String_val (tarballv);
2521 const char *directory = String_val (directoryv);
2524 caml_enter_blocking_section ();
2525 r = guestfs_tgz_in (g, tarball, directory);
2526 caml_leave_blocking_section ();
2528 ocaml_guestfs_raise_error (g, "tgz_in");
2535 ocaml_guestfs_tgz_out (value gv, value directoryv, value tarballv)
2537 CAMLparam3 (gv, directoryv, tarballv);
2540 guestfs_h *g = Guestfs_val (gv);
2542 caml_failwith ("tgz_out: used handle after closing it");
2544 const char *directory = String_val (directoryv);
2545 const char *tarball = String_val (tarballv);
2548 caml_enter_blocking_section ();
2549 r = guestfs_tgz_out (g, directory, tarball);
2550 caml_leave_blocking_section ();
2552 ocaml_guestfs_raise_error (g, "tgz_out");
2559 ocaml_guestfs_mount_ro (value gv, value devicev, value mountpointv)
2561 CAMLparam3 (gv, devicev, mountpointv);
2564 guestfs_h *g = Guestfs_val (gv);
2566 caml_failwith ("mount_ro: used handle after closing it");
2568 const char *device = String_val (devicev);
2569 const char *mountpoint = String_val (mountpointv);
2572 caml_enter_blocking_section ();
2573 r = guestfs_mount_ro (g, device, mountpoint);
2574 caml_leave_blocking_section ();
2576 ocaml_guestfs_raise_error (g, "mount_ro");
2583 ocaml_guestfs_mount_options (value gv, value optionsv, value devicev, value mountpointv)
2585 CAMLparam4 (gv, optionsv, devicev, mountpointv);
2588 guestfs_h *g = Guestfs_val (gv);
2590 caml_failwith ("mount_options: used handle after closing it");
2592 const char *options = String_val (optionsv);
2593 const char *device = String_val (devicev);
2594 const char *mountpoint = String_val (mountpointv);
2597 caml_enter_blocking_section ();
2598 r = guestfs_mount_options (g, options, device, mountpoint);
2599 caml_leave_blocking_section ();
2601 ocaml_guestfs_raise_error (g, "mount_options");
2608 ocaml_guestfs_mount_vfs (value gv, value optionsv, value vfstypev, value devicev, value mountpointv)
2610 CAMLparam5 (gv, optionsv, vfstypev, devicev, mountpointv);
2613 guestfs_h *g = Guestfs_val (gv);
2615 caml_failwith ("mount_vfs: used handle after closing it");
2617 const char *options = String_val (optionsv);
2618 const char *vfstype = String_val (vfstypev);
2619 const char *device = String_val (devicev);
2620 const char *mountpoint = String_val (mountpointv);
2623 caml_enter_blocking_section ();
2624 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2625 caml_leave_blocking_section ();
2627 ocaml_guestfs_raise_error (g, "mount_vfs");
2634 ocaml_guestfs_debug (value gv, value subcmdv, value extraargsv)
2636 CAMLparam3 (gv, subcmdv, extraargsv);
2639 guestfs_h *g = Guestfs_val (gv);
2641 caml_failwith ("debug: used handle after closing it");
2643 const char *subcmd = String_val (subcmdv);
2644 char **extraargs = ocaml_guestfs_strings_val (g, extraargsv);
2647 caml_enter_blocking_section ();
2648 r = guestfs_debug (g, subcmd, extraargs);
2649 caml_leave_blocking_section ();
2650 ocaml_guestfs_free_strings (extraargs);
2652 ocaml_guestfs_raise_error (g, "debug");
2654 rv = caml_copy_string (r);
2660 ocaml_guestfs_lvremove (value gv, value devicev)
2662 CAMLparam2 (gv, devicev);
2665 guestfs_h *g = Guestfs_val (gv);
2667 caml_failwith ("lvremove: used handle after closing it");
2669 const char *device = String_val (devicev);
2672 caml_enter_blocking_section ();
2673 r = guestfs_lvremove (g, device);
2674 caml_leave_blocking_section ();
2676 ocaml_guestfs_raise_error (g, "lvremove");
2683 ocaml_guestfs_vgremove (value gv, value vgnamev)
2685 CAMLparam2 (gv, vgnamev);
2688 guestfs_h *g = Guestfs_val (gv);
2690 caml_failwith ("vgremove: used handle after closing it");
2692 const char *vgname = String_val (vgnamev);
2695 caml_enter_blocking_section ();
2696 r = guestfs_vgremove (g, vgname);
2697 caml_leave_blocking_section ();
2699 ocaml_guestfs_raise_error (g, "vgremove");
2706 ocaml_guestfs_pvremove (value gv, value devicev)
2708 CAMLparam2 (gv, devicev);
2711 guestfs_h *g = Guestfs_val (gv);
2713 caml_failwith ("pvremove: used handle after closing it");
2715 const char *device = String_val (devicev);
2718 caml_enter_blocking_section ();
2719 r = guestfs_pvremove (g, device);
2720 caml_leave_blocking_section ();
2722 ocaml_guestfs_raise_error (g, "pvremove");
2729 ocaml_guestfs_set_e2label (value gv, value devicev, value labelv)
2731 CAMLparam3 (gv, devicev, labelv);
2734 guestfs_h *g = Guestfs_val (gv);
2736 caml_failwith ("set_e2label: used handle after closing it");
2738 const char *device = String_val (devicev);
2739 const char *label = String_val (labelv);
2742 caml_enter_blocking_section ();
2743 r = guestfs_set_e2label (g, device, label);
2744 caml_leave_blocking_section ();
2746 ocaml_guestfs_raise_error (g, "set_e2label");
2753 ocaml_guestfs_get_e2label (value gv, value devicev)
2755 CAMLparam2 (gv, devicev);
2758 guestfs_h *g = Guestfs_val (gv);
2760 caml_failwith ("get_e2label: used handle after closing it");
2762 const char *device = String_val (devicev);
2765 caml_enter_blocking_section ();
2766 r = guestfs_get_e2label (g, device);
2767 caml_leave_blocking_section ();
2769 ocaml_guestfs_raise_error (g, "get_e2label");
2771 rv = caml_copy_string (r);
2777 ocaml_guestfs_set_e2uuid (value gv, value devicev, value uuidv)
2779 CAMLparam3 (gv, devicev, uuidv);
2782 guestfs_h *g = Guestfs_val (gv);
2784 caml_failwith ("set_e2uuid: used handle after closing it");
2786 const char *device = String_val (devicev);
2787 const char *uuid = String_val (uuidv);
2790 caml_enter_blocking_section ();
2791 r = guestfs_set_e2uuid (g, device, uuid);
2792 caml_leave_blocking_section ();
2794 ocaml_guestfs_raise_error (g, "set_e2uuid");
2801 ocaml_guestfs_get_e2uuid (value gv, value devicev)
2803 CAMLparam2 (gv, devicev);
2806 guestfs_h *g = Guestfs_val (gv);
2808 caml_failwith ("get_e2uuid: used handle after closing it");
2810 const char *device = String_val (devicev);
2813 caml_enter_blocking_section ();
2814 r = guestfs_get_e2uuid (g, device);
2815 caml_leave_blocking_section ();
2817 ocaml_guestfs_raise_error (g, "get_e2uuid");
2819 rv = caml_copy_string (r);
2825 ocaml_guestfs_fsck (value gv, value fstypev, value devicev)
2827 CAMLparam3 (gv, fstypev, devicev);
2830 guestfs_h *g = Guestfs_val (gv);
2832 caml_failwith ("fsck: used handle after closing it");
2834 const char *fstype = String_val (fstypev);
2835 const char *device = String_val (devicev);
2838 caml_enter_blocking_section ();
2839 r = guestfs_fsck (g, fstype, device);
2840 caml_leave_blocking_section ();
2842 ocaml_guestfs_raise_error (g, "fsck");
2849 ocaml_guestfs_zero (value gv, value devicev)
2851 CAMLparam2 (gv, devicev);
2854 guestfs_h *g = Guestfs_val (gv);
2856 caml_failwith ("zero: used handle after closing it");
2858 const char *device = String_val (devicev);
2861 caml_enter_blocking_section ();
2862 r = guestfs_zero (g, device);
2863 caml_leave_blocking_section ();
2865 ocaml_guestfs_raise_error (g, "zero");
2872 ocaml_guestfs_grub_install (value gv, value rootv, value devicev)
2874 CAMLparam3 (gv, rootv, devicev);
2877 guestfs_h *g = Guestfs_val (gv);
2879 caml_failwith ("grub_install: used handle after closing it");
2881 const char *root = String_val (rootv);
2882 const char *device = String_val (devicev);
2885 caml_enter_blocking_section ();
2886 r = guestfs_grub_install (g, root, device);
2887 caml_leave_blocking_section ();
2889 ocaml_guestfs_raise_error (g, "grub_install");
2896 ocaml_guestfs_cp (value gv, value srcv, value destv)
2898 CAMLparam3 (gv, srcv, destv);
2901 guestfs_h *g = Guestfs_val (gv);
2903 caml_failwith ("cp: used handle after closing it");
2905 const char *src = String_val (srcv);
2906 const char *dest = String_val (destv);
2909 caml_enter_blocking_section ();
2910 r = guestfs_cp (g, src, dest);
2911 caml_leave_blocking_section ();
2913 ocaml_guestfs_raise_error (g, "cp");
2920 ocaml_guestfs_cp_a (value gv, value srcv, value destv)
2922 CAMLparam3 (gv, srcv, destv);
2925 guestfs_h *g = Guestfs_val (gv);
2927 caml_failwith ("cp_a: used handle after closing it");
2929 const char *src = String_val (srcv);
2930 const char *dest = String_val (destv);
2933 caml_enter_blocking_section ();
2934 r = guestfs_cp_a (g, src, dest);
2935 caml_leave_blocking_section ();
2937 ocaml_guestfs_raise_error (g, "cp_a");
2944 ocaml_guestfs_mv (value gv, value srcv, value destv)
2946 CAMLparam3 (gv, srcv, destv);
2949 guestfs_h *g = Guestfs_val (gv);
2951 caml_failwith ("mv: used handle after closing it");
2953 const char *src = String_val (srcv);
2954 const char *dest = String_val (destv);
2957 caml_enter_blocking_section ();
2958 r = guestfs_mv (g, src, dest);
2959 caml_leave_blocking_section ();
2961 ocaml_guestfs_raise_error (g, "mv");
2968 ocaml_guestfs_drop_caches (value gv, value whattodropv)
2970 CAMLparam2 (gv, whattodropv);
2973 guestfs_h *g = Guestfs_val (gv);
2975 caml_failwith ("drop_caches: used handle after closing it");
2977 int whattodrop = Int_val (whattodropv);
2980 caml_enter_blocking_section ();
2981 r = guestfs_drop_caches (g, whattodrop);
2982 caml_leave_blocking_section ();
2984 ocaml_guestfs_raise_error (g, "drop_caches");
2991 ocaml_guestfs_dmesg (value gv)
2996 guestfs_h *g = Guestfs_val (gv);
2998 caml_failwith ("dmesg: used handle after closing it");
3002 caml_enter_blocking_section ();
3003 r = guestfs_dmesg (g);
3004 caml_leave_blocking_section ();
3006 ocaml_guestfs_raise_error (g, "dmesg");
3008 rv = caml_copy_string (r);
3014 ocaml_guestfs_ping_daemon (value gv)
3019 guestfs_h *g = Guestfs_val (gv);
3021 caml_failwith ("ping_daemon: used handle after closing it");
3025 caml_enter_blocking_section ();
3026 r = guestfs_ping_daemon (g);
3027 caml_leave_blocking_section ();
3029 ocaml_guestfs_raise_error (g, "ping_daemon");
3036 ocaml_guestfs_equal (value gv, value file1v, value file2v)
3038 CAMLparam3 (gv, file1v, file2v);
3041 guestfs_h *g = Guestfs_val (gv);
3043 caml_failwith ("equal: used handle after closing it");
3045 const char *file1 = String_val (file1v);
3046 const char *file2 = String_val (file2v);
3049 caml_enter_blocking_section ();
3050 r = guestfs_equal (g, file1, file2);
3051 caml_leave_blocking_section ();
3053 ocaml_guestfs_raise_error (g, "equal");
3060 ocaml_guestfs_strings (value gv, value pathv)
3062 CAMLparam2 (gv, pathv);
3065 guestfs_h *g = Guestfs_val (gv);
3067 caml_failwith ("strings: used handle after closing it");
3069 const char *path = String_val (pathv);
3073 caml_enter_blocking_section ();
3074 r = guestfs_strings (g, path);
3075 caml_leave_blocking_section ();
3077 ocaml_guestfs_raise_error (g, "strings");
3079 rv = caml_copy_string_array ((const char **) r);
3080 for (i = 0; r[i] != NULL; ++i) free (r[i]);
3086 ocaml_guestfs_strings_e (value gv, value encodingv, value pathv)
3088 CAMLparam3 (gv, encodingv, pathv);
3091 guestfs_h *g = Guestfs_val (gv);
3093 caml_failwith ("strings_e: used handle after closing it");
3095 const char *encoding = String_val (encodingv);
3096 const char *path = String_val (pathv);
3100 caml_enter_blocking_section ();
3101 r = guestfs_strings_e (g, encoding, path);
3102 caml_leave_blocking_section ();
3104 ocaml_guestfs_raise_error (g, "strings_e");
3106 rv = caml_copy_string_array ((const char **) r);
3107 for (i = 0; r[i] != NULL; ++i) free (r[i]);
3113 ocaml_guestfs_hexdump (value gv, value pathv)
3115 CAMLparam2 (gv, pathv);
3118 guestfs_h *g = Guestfs_val (gv);
3120 caml_failwith ("hexdump: used handle after closing it");
3122 const char *path = String_val (pathv);
3125 caml_enter_blocking_section ();
3126 r = guestfs_hexdump (g, path);
3127 caml_leave_blocking_section ();
3129 ocaml_guestfs_raise_error (g, "hexdump");
3131 rv = caml_copy_string (r);