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_path (value gv, value pathv)
471 CAMLparam2 (gv, pathv);
474 guestfs_h *g = Guestfs_val (gv);
476 caml_failwith ("set_path: used handle after closing it");
478 const char *path = String_val (pathv);
481 caml_enter_blocking_section ();
482 r = guestfs_set_path (g, path);
483 caml_leave_blocking_section ();
485 ocaml_guestfs_raise_error (g, "set_path");
492 ocaml_guestfs_get_path (value gv)
497 guestfs_h *g = Guestfs_val (gv);
499 caml_failwith ("get_path: used handle after closing it");
503 caml_enter_blocking_section ();
504 r = guestfs_get_path (g);
505 caml_leave_blocking_section ();
507 ocaml_guestfs_raise_error (g, "get_path");
509 rv = caml_copy_string (r);
514 ocaml_guestfs_set_autosync (value gv, value autosyncv)
516 CAMLparam2 (gv, autosyncv);
519 guestfs_h *g = Guestfs_val (gv);
521 caml_failwith ("set_autosync: used handle after closing it");
523 int autosync = Bool_val (autosyncv);
526 caml_enter_blocking_section ();
527 r = guestfs_set_autosync (g, autosync);
528 caml_leave_blocking_section ();
530 ocaml_guestfs_raise_error (g, "set_autosync");
537 ocaml_guestfs_get_autosync (value gv)
542 guestfs_h *g = Guestfs_val (gv);
544 caml_failwith ("get_autosync: used handle after closing it");
548 caml_enter_blocking_section ();
549 r = guestfs_get_autosync (g);
550 caml_leave_blocking_section ();
552 ocaml_guestfs_raise_error (g, "get_autosync");
559 ocaml_guestfs_set_verbose (value gv, value verbosev)
561 CAMLparam2 (gv, verbosev);
564 guestfs_h *g = Guestfs_val (gv);
566 caml_failwith ("set_verbose: used handle after closing it");
568 int verbose = Bool_val (verbosev);
571 caml_enter_blocking_section ();
572 r = guestfs_set_verbose (g, verbose);
573 caml_leave_blocking_section ();
575 ocaml_guestfs_raise_error (g, "set_verbose");
582 ocaml_guestfs_get_verbose (value gv)
587 guestfs_h *g = Guestfs_val (gv);
589 caml_failwith ("get_verbose: used handle after closing it");
593 caml_enter_blocking_section ();
594 r = guestfs_get_verbose (g);
595 caml_leave_blocking_section ();
597 ocaml_guestfs_raise_error (g, "get_verbose");
604 ocaml_guestfs_is_ready (value gv)
609 guestfs_h *g = Guestfs_val (gv);
611 caml_failwith ("is_ready: used handle after closing it");
615 caml_enter_blocking_section ();
616 r = guestfs_is_ready (g);
617 caml_leave_blocking_section ();
619 ocaml_guestfs_raise_error (g, "is_ready");
626 ocaml_guestfs_is_config (value gv)
631 guestfs_h *g = Guestfs_val (gv);
633 caml_failwith ("is_config: used handle after closing it");
637 caml_enter_blocking_section ();
638 r = guestfs_is_config (g);
639 caml_leave_blocking_section ();
641 ocaml_guestfs_raise_error (g, "is_config");
648 ocaml_guestfs_is_launching (value gv)
653 guestfs_h *g = Guestfs_val (gv);
655 caml_failwith ("is_launching: used handle after closing it");
659 caml_enter_blocking_section ();
660 r = guestfs_is_launching (g);
661 caml_leave_blocking_section ();
663 ocaml_guestfs_raise_error (g, "is_launching");
670 ocaml_guestfs_is_busy (value gv)
675 guestfs_h *g = Guestfs_val (gv);
677 caml_failwith ("is_busy: used handle after closing it");
681 caml_enter_blocking_section ();
682 r = guestfs_is_busy (g);
683 caml_leave_blocking_section ();
685 ocaml_guestfs_raise_error (g, "is_busy");
692 ocaml_guestfs_get_state (value gv)
697 guestfs_h *g = Guestfs_val (gv);
699 caml_failwith ("get_state: used handle after closing it");
703 caml_enter_blocking_section ();
704 r = guestfs_get_state (g);
705 caml_leave_blocking_section ();
707 ocaml_guestfs_raise_error (g, "get_state");
714 ocaml_guestfs_set_busy (value gv)
719 guestfs_h *g = Guestfs_val (gv);
721 caml_failwith ("set_busy: used handle after closing it");
725 caml_enter_blocking_section ();
726 r = guestfs_set_busy (g);
727 caml_leave_blocking_section ();
729 ocaml_guestfs_raise_error (g, "set_busy");
736 ocaml_guestfs_set_ready (value gv)
741 guestfs_h *g = Guestfs_val (gv);
743 caml_failwith ("set_ready: used handle after closing it");
747 caml_enter_blocking_section ();
748 r = guestfs_set_ready (g);
749 caml_leave_blocking_section ();
751 ocaml_guestfs_raise_error (g, "set_ready");
758 ocaml_guestfs_mount (value gv, value devicev, value mountpointv)
760 CAMLparam3 (gv, devicev, mountpointv);
763 guestfs_h *g = Guestfs_val (gv);
765 caml_failwith ("mount: used handle after closing it");
767 const char *device = String_val (devicev);
768 const char *mountpoint = String_val (mountpointv);
771 caml_enter_blocking_section ();
772 r = guestfs_mount (g, device, mountpoint);
773 caml_leave_blocking_section ();
775 ocaml_guestfs_raise_error (g, "mount");
782 ocaml_guestfs_sync (value gv)
787 guestfs_h *g = Guestfs_val (gv);
789 caml_failwith ("sync: used handle after closing it");
793 caml_enter_blocking_section ();
794 r = guestfs_sync (g);
795 caml_leave_blocking_section ();
797 ocaml_guestfs_raise_error (g, "sync");
804 ocaml_guestfs_touch (value gv, value pathv)
806 CAMLparam2 (gv, pathv);
809 guestfs_h *g = Guestfs_val (gv);
811 caml_failwith ("touch: used handle after closing it");
813 const char *path = String_val (pathv);
816 caml_enter_blocking_section ();
817 r = guestfs_touch (g, path);
818 caml_leave_blocking_section ();
820 ocaml_guestfs_raise_error (g, "touch");
827 ocaml_guestfs_cat (value gv, value pathv)
829 CAMLparam2 (gv, pathv);
832 guestfs_h *g = Guestfs_val (gv);
834 caml_failwith ("cat: used handle after closing it");
836 const char *path = String_val (pathv);
839 caml_enter_blocking_section ();
840 r = guestfs_cat (g, path);
841 caml_leave_blocking_section ();
843 ocaml_guestfs_raise_error (g, "cat");
845 rv = caml_copy_string (r);
851 ocaml_guestfs_ll (value gv, value directoryv)
853 CAMLparam2 (gv, directoryv);
856 guestfs_h *g = Guestfs_val (gv);
858 caml_failwith ("ll: used handle after closing it");
860 const char *directory = String_val (directoryv);
863 caml_enter_blocking_section ();
864 r = guestfs_ll (g, directory);
865 caml_leave_blocking_section ();
867 ocaml_guestfs_raise_error (g, "ll");
869 rv = caml_copy_string (r);
875 ocaml_guestfs_ls (value gv, value directoryv)
877 CAMLparam2 (gv, directoryv);
880 guestfs_h *g = Guestfs_val (gv);
882 caml_failwith ("ls: used handle after closing it");
884 const char *directory = String_val (directoryv);
888 caml_enter_blocking_section ();
889 r = guestfs_ls (g, directory);
890 caml_leave_blocking_section ();
892 ocaml_guestfs_raise_error (g, "ls");
894 rv = caml_copy_string_array ((const char **) r);
895 for (i = 0; r[i] != NULL; ++i) free (r[i]);
901 ocaml_guestfs_list_devices (value gv)
906 guestfs_h *g = Guestfs_val (gv);
908 caml_failwith ("list_devices: used handle after closing it");
913 caml_enter_blocking_section ();
914 r = guestfs_list_devices (g);
915 caml_leave_blocking_section ();
917 ocaml_guestfs_raise_error (g, "list_devices");
919 rv = caml_copy_string_array ((const char **) r);
920 for (i = 0; r[i] != NULL; ++i) free (r[i]);
926 ocaml_guestfs_list_partitions (value gv)
931 guestfs_h *g = Guestfs_val (gv);
933 caml_failwith ("list_partitions: used handle after closing it");
938 caml_enter_blocking_section ();
939 r = guestfs_list_partitions (g);
940 caml_leave_blocking_section ();
942 ocaml_guestfs_raise_error (g, "list_partitions");
944 rv = caml_copy_string_array ((const char **) r);
945 for (i = 0; r[i] != NULL; ++i) free (r[i]);
951 ocaml_guestfs_pvs (value gv)
956 guestfs_h *g = Guestfs_val (gv);
958 caml_failwith ("pvs: used handle after closing it");
963 caml_enter_blocking_section ();
965 caml_leave_blocking_section ();
967 ocaml_guestfs_raise_error (g, "pvs");
969 rv = caml_copy_string_array ((const char **) r);
970 for (i = 0; r[i] != NULL; ++i) free (r[i]);
976 ocaml_guestfs_vgs (value gv)
981 guestfs_h *g = Guestfs_val (gv);
983 caml_failwith ("vgs: used handle after closing it");
988 caml_enter_blocking_section ();
990 caml_leave_blocking_section ();
992 ocaml_guestfs_raise_error (g, "vgs");
994 rv = caml_copy_string_array ((const char **) r);
995 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1001 ocaml_guestfs_lvs (value gv)
1006 guestfs_h *g = Guestfs_val (gv);
1008 caml_failwith ("lvs: used handle after closing it");
1013 caml_enter_blocking_section ();
1014 r = guestfs_lvs (g);
1015 caml_leave_blocking_section ();
1017 ocaml_guestfs_raise_error (g, "lvs");
1019 rv = caml_copy_string_array ((const char **) r);
1020 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1026 ocaml_guestfs_pvs_full (value gv)
1031 guestfs_h *g = Guestfs_val (gv);
1033 caml_failwith ("pvs_full: used handle after closing it");
1035 struct guestfs_lvm_pv_list *r;
1037 caml_enter_blocking_section ();
1038 r = guestfs_pvs_full (g);
1039 caml_leave_blocking_section ();
1041 ocaml_guestfs_raise_error (g, "pvs_full");
1043 rv = copy_lvm_pv_list (r);
1044 guestfs_free_lvm_pv_list (r);
1049 ocaml_guestfs_vgs_full (value gv)
1054 guestfs_h *g = Guestfs_val (gv);
1056 caml_failwith ("vgs_full: used handle after closing it");
1058 struct guestfs_lvm_vg_list *r;
1060 caml_enter_blocking_section ();
1061 r = guestfs_vgs_full (g);
1062 caml_leave_blocking_section ();
1064 ocaml_guestfs_raise_error (g, "vgs_full");
1066 rv = copy_lvm_vg_list (r);
1067 guestfs_free_lvm_vg_list (r);
1072 ocaml_guestfs_lvs_full (value gv)
1077 guestfs_h *g = Guestfs_val (gv);
1079 caml_failwith ("lvs_full: used handle after closing it");
1081 struct guestfs_lvm_lv_list *r;
1083 caml_enter_blocking_section ();
1084 r = guestfs_lvs_full (g);
1085 caml_leave_blocking_section ();
1087 ocaml_guestfs_raise_error (g, "lvs_full");
1089 rv = copy_lvm_lv_list (r);
1090 guestfs_free_lvm_lv_list (r);
1095 ocaml_guestfs_read_lines (value gv, value pathv)
1097 CAMLparam2 (gv, pathv);
1100 guestfs_h *g = Guestfs_val (gv);
1102 caml_failwith ("read_lines: used handle after closing it");
1104 const char *path = String_val (pathv);
1108 caml_enter_blocking_section ();
1109 r = guestfs_read_lines (g, path);
1110 caml_leave_blocking_section ();
1112 ocaml_guestfs_raise_error (g, "read_lines");
1114 rv = caml_copy_string_array ((const char **) r);
1115 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1121 ocaml_guestfs_aug_init (value gv, value rootv, value flagsv)
1123 CAMLparam3 (gv, rootv, flagsv);
1126 guestfs_h *g = Guestfs_val (gv);
1128 caml_failwith ("aug_init: used handle after closing it");
1130 const char *root = String_val (rootv);
1131 int flags = Int_val (flagsv);
1134 caml_enter_blocking_section ();
1135 r = guestfs_aug_init (g, root, flags);
1136 caml_leave_blocking_section ();
1138 ocaml_guestfs_raise_error (g, "aug_init");
1145 ocaml_guestfs_aug_close (value gv)
1150 guestfs_h *g = Guestfs_val (gv);
1152 caml_failwith ("aug_close: used handle after closing it");
1156 caml_enter_blocking_section ();
1157 r = guestfs_aug_close (g);
1158 caml_leave_blocking_section ();
1160 ocaml_guestfs_raise_error (g, "aug_close");
1167 ocaml_guestfs_aug_defvar (value gv, value namev, value exprv)
1169 CAMLparam3 (gv, namev, exprv);
1172 guestfs_h *g = Guestfs_val (gv);
1174 caml_failwith ("aug_defvar: used handle after closing it");
1176 const char *name = String_val (namev);
1178 exprv != Val_int (0) ? String_val (Field (exprv, 0)) : NULL;
1181 caml_enter_blocking_section ();
1182 r = guestfs_aug_defvar (g, name, expr);
1183 caml_leave_blocking_section ();
1185 ocaml_guestfs_raise_error (g, "aug_defvar");
1192 ocaml_guestfs_aug_defnode (value gv, value namev, value exprv, value valv)
1194 CAMLparam4 (gv, namev, exprv, valv);
1197 guestfs_h *g = Guestfs_val (gv);
1199 caml_failwith ("aug_defnode: used handle after closing it");
1201 const char *name = String_val (namev);
1202 const char *expr = String_val (exprv);
1203 const char *val = String_val (valv);
1204 struct guestfs_int_bool *r;
1206 caml_enter_blocking_section ();
1207 r = guestfs_aug_defnode (g, name, expr, val);
1208 caml_leave_blocking_section ();
1210 ocaml_guestfs_raise_error (g, "aug_defnode");
1212 rv = caml_alloc (2, 0);
1213 Store_field (rv, 0, Val_int (r->i));
1214 Store_field (rv, 1, Val_bool (r->b));
1215 guestfs_free_int_bool (r);
1220 ocaml_guestfs_aug_get (value gv, value pathv)
1222 CAMLparam2 (gv, pathv);
1225 guestfs_h *g = Guestfs_val (gv);
1227 caml_failwith ("aug_get: used handle after closing it");
1229 const char *path = String_val (pathv);
1232 caml_enter_blocking_section ();
1233 r = guestfs_aug_get (g, path);
1234 caml_leave_blocking_section ();
1236 ocaml_guestfs_raise_error (g, "aug_get");
1238 rv = caml_copy_string (r);
1244 ocaml_guestfs_aug_set (value gv, value pathv, value valv)
1246 CAMLparam3 (gv, pathv, valv);
1249 guestfs_h *g = Guestfs_val (gv);
1251 caml_failwith ("aug_set: used handle after closing it");
1253 const char *path = String_val (pathv);
1254 const char *val = String_val (valv);
1257 caml_enter_blocking_section ();
1258 r = guestfs_aug_set (g, path, val);
1259 caml_leave_blocking_section ();
1261 ocaml_guestfs_raise_error (g, "aug_set");
1268 ocaml_guestfs_aug_insert (value gv, value pathv, value labelv, value beforev)
1270 CAMLparam4 (gv, pathv, labelv, beforev);
1273 guestfs_h *g = Guestfs_val (gv);
1275 caml_failwith ("aug_insert: used handle after closing it");
1277 const char *path = String_val (pathv);
1278 const char *label = String_val (labelv);
1279 int before = Bool_val (beforev);
1282 caml_enter_blocking_section ();
1283 r = guestfs_aug_insert (g, path, label, before);
1284 caml_leave_blocking_section ();
1286 ocaml_guestfs_raise_error (g, "aug_insert");
1293 ocaml_guestfs_aug_rm (value gv, value pathv)
1295 CAMLparam2 (gv, pathv);
1298 guestfs_h *g = Guestfs_val (gv);
1300 caml_failwith ("aug_rm: used handle after closing it");
1302 const char *path = String_val (pathv);
1305 caml_enter_blocking_section ();
1306 r = guestfs_aug_rm (g, path);
1307 caml_leave_blocking_section ();
1309 ocaml_guestfs_raise_error (g, "aug_rm");
1316 ocaml_guestfs_aug_mv (value gv, value srcv, value destv)
1318 CAMLparam3 (gv, srcv, destv);
1321 guestfs_h *g = Guestfs_val (gv);
1323 caml_failwith ("aug_mv: used handle after closing it");
1325 const char *src = String_val (srcv);
1326 const char *dest = String_val (destv);
1329 caml_enter_blocking_section ();
1330 r = guestfs_aug_mv (g, src, dest);
1331 caml_leave_blocking_section ();
1333 ocaml_guestfs_raise_error (g, "aug_mv");
1340 ocaml_guestfs_aug_match (value gv, value pathv)
1342 CAMLparam2 (gv, pathv);
1345 guestfs_h *g = Guestfs_val (gv);
1347 caml_failwith ("aug_match: used handle after closing it");
1349 const char *path = String_val (pathv);
1353 caml_enter_blocking_section ();
1354 r = guestfs_aug_match (g, path);
1355 caml_leave_blocking_section ();
1357 ocaml_guestfs_raise_error (g, "aug_match");
1359 rv = caml_copy_string_array ((const char **) r);
1360 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1366 ocaml_guestfs_aug_save (value gv)
1371 guestfs_h *g = Guestfs_val (gv);
1373 caml_failwith ("aug_save: used handle after closing it");
1377 caml_enter_blocking_section ();
1378 r = guestfs_aug_save (g);
1379 caml_leave_blocking_section ();
1381 ocaml_guestfs_raise_error (g, "aug_save");
1388 ocaml_guestfs_aug_load (value gv)
1393 guestfs_h *g = Guestfs_val (gv);
1395 caml_failwith ("aug_load: used handle after closing it");
1399 caml_enter_blocking_section ();
1400 r = guestfs_aug_load (g);
1401 caml_leave_blocking_section ();
1403 ocaml_guestfs_raise_error (g, "aug_load");
1410 ocaml_guestfs_aug_ls (value gv, value pathv)
1412 CAMLparam2 (gv, pathv);
1415 guestfs_h *g = Guestfs_val (gv);
1417 caml_failwith ("aug_ls: used handle after closing it");
1419 const char *path = String_val (pathv);
1423 caml_enter_blocking_section ();
1424 r = guestfs_aug_ls (g, path);
1425 caml_leave_blocking_section ();
1427 ocaml_guestfs_raise_error (g, "aug_ls");
1429 rv = caml_copy_string_array ((const char **) r);
1430 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1436 ocaml_guestfs_rm (value gv, value pathv)
1438 CAMLparam2 (gv, pathv);
1441 guestfs_h *g = Guestfs_val (gv);
1443 caml_failwith ("rm: used handle after closing it");
1445 const char *path = String_val (pathv);
1448 caml_enter_blocking_section ();
1449 r = guestfs_rm (g, path);
1450 caml_leave_blocking_section ();
1452 ocaml_guestfs_raise_error (g, "rm");
1459 ocaml_guestfs_rmdir (value gv, value pathv)
1461 CAMLparam2 (gv, pathv);
1464 guestfs_h *g = Guestfs_val (gv);
1466 caml_failwith ("rmdir: used handle after closing it");
1468 const char *path = String_val (pathv);
1471 caml_enter_blocking_section ();
1472 r = guestfs_rmdir (g, path);
1473 caml_leave_blocking_section ();
1475 ocaml_guestfs_raise_error (g, "rmdir");
1482 ocaml_guestfs_rm_rf (value gv, value pathv)
1484 CAMLparam2 (gv, pathv);
1487 guestfs_h *g = Guestfs_val (gv);
1489 caml_failwith ("rm_rf: used handle after closing it");
1491 const char *path = String_val (pathv);
1494 caml_enter_blocking_section ();
1495 r = guestfs_rm_rf (g, path);
1496 caml_leave_blocking_section ();
1498 ocaml_guestfs_raise_error (g, "rm_rf");
1505 ocaml_guestfs_mkdir (value gv, value pathv)
1507 CAMLparam2 (gv, pathv);
1510 guestfs_h *g = Guestfs_val (gv);
1512 caml_failwith ("mkdir: used handle after closing it");
1514 const char *path = String_val (pathv);
1517 caml_enter_blocking_section ();
1518 r = guestfs_mkdir (g, path);
1519 caml_leave_blocking_section ();
1521 ocaml_guestfs_raise_error (g, "mkdir");
1528 ocaml_guestfs_mkdir_p (value gv, value pathv)
1530 CAMLparam2 (gv, pathv);
1533 guestfs_h *g = Guestfs_val (gv);
1535 caml_failwith ("mkdir_p: used handle after closing it");
1537 const char *path = String_val (pathv);
1540 caml_enter_blocking_section ();
1541 r = guestfs_mkdir_p (g, path);
1542 caml_leave_blocking_section ();
1544 ocaml_guestfs_raise_error (g, "mkdir_p");
1551 ocaml_guestfs_chmod (value gv, value modev, value pathv)
1553 CAMLparam3 (gv, modev, pathv);
1556 guestfs_h *g = Guestfs_val (gv);
1558 caml_failwith ("chmod: used handle after closing it");
1560 int mode = Int_val (modev);
1561 const char *path = String_val (pathv);
1564 caml_enter_blocking_section ();
1565 r = guestfs_chmod (g, mode, path);
1566 caml_leave_blocking_section ();
1568 ocaml_guestfs_raise_error (g, "chmod");
1575 ocaml_guestfs_chown (value gv, value ownerv, value groupv, value pathv)
1577 CAMLparam4 (gv, ownerv, groupv, pathv);
1580 guestfs_h *g = Guestfs_val (gv);
1582 caml_failwith ("chown: used handle after closing it");
1584 int owner = Int_val (ownerv);
1585 int group = Int_val (groupv);
1586 const char *path = String_val (pathv);
1589 caml_enter_blocking_section ();
1590 r = guestfs_chown (g, owner, group, path);
1591 caml_leave_blocking_section ();
1593 ocaml_guestfs_raise_error (g, "chown");
1600 ocaml_guestfs_exists (value gv, value pathv)
1602 CAMLparam2 (gv, pathv);
1605 guestfs_h *g = Guestfs_val (gv);
1607 caml_failwith ("exists: used handle after closing it");
1609 const char *path = String_val (pathv);
1612 caml_enter_blocking_section ();
1613 r = guestfs_exists (g, path);
1614 caml_leave_blocking_section ();
1616 ocaml_guestfs_raise_error (g, "exists");
1623 ocaml_guestfs_is_file (value gv, value pathv)
1625 CAMLparam2 (gv, pathv);
1628 guestfs_h *g = Guestfs_val (gv);
1630 caml_failwith ("is_file: used handle after closing it");
1632 const char *path = String_val (pathv);
1635 caml_enter_blocking_section ();
1636 r = guestfs_is_file (g, path);
1637 caml_leave_blocking_section ();
1639 ocaml_guestfs_raise_error (g, "is_file");
1646 ocaml_guestfs_is_dir (value gv, value pathv)
1648 CAMLparam2 (gv, pathv);
1651 guestfs_h *g = Guestfs_val (gv);
1653 caml_failwith ("is_dir: used handle after closing it");
1655 const char *path = String_val (pathv);
1658 caml_enter_blocking_section ();
1659 r = guestfs_is_dir (g, path);
1660 caml_leave_blocking_section ();
1662 ocaml_guestfs_raise_error (g, "is_dir");
1669 ocaml_guestfs_pvcreate (value gv, value devicev)
1671 CAMLparam2 (gv, devicev);
1674 guestfs_h *g = Guestfs_val (gv);
1676 caml_failwith ("pvcreate: used handle after closing it");
1678 const char *device = String_val (devicev);
1681 caml_enter_blocking_section ();
1682 r = guestfs_pvcreate (g, device);
1683 caml_leave_blocking_section ();
1685 ocaml_guestfs_raise_error (g, "pvcreate");
1692 ocaml_guestfs_vgcreate (value gv, value volgroupv, value physvolsv)
1694 CAMLparam3 (gv, volgroupv, physvolsv);
1697 guestfs_h *g = Guestfs_val (gv);
1699 caml_failwith ("vgcreate: used handle after closing it");
1701 const char *volgroup = String_val (volgroupv);
1702 char **physvols = ocaml_guestfs_strings_val (physvolsv);
1705 caml_enter_blocking_section ();
1706 r = guestfs_vgcreate (g, volgroup, physvols);
1707 caml_leave_blocking_section ();
1708 ocaml_guestfs_free_strings (physvols);
1710 ocaml_guestfs_raise_error (g, "vgcreate");
1717 ocaml_guestfs_lvcreate (value gv, value logvolv, value volgroupv, value mbytesv)
1719 CAMLparam4 (gv, logvolv, volgroupv, mbytesv);
1722 guestfs_h *g = Guestfs_val (gv);
1724 caml_failwith ("lvcreate: used handle after closing it");
1726 const char *logvol = String_val (logvolv);
1727 const char *volgroup = String_val (volgroupv);
1728 int mbytes = Int_val (mbytesv);
1731 caml_enter_blocking_section ();
1732 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1733 caml_leave_blocking_section ();
1735 ocaml_guestfs_raise_error (g, "lvcreate");
1742 ocaml_guestfs_mkfs (value gv, value fstypev, value devicev)
1744 CAMLparam3 (gv, fstypev, devicev);
1747 guestfs_h *g = Guestfs_val (gv);
1749 caml_failwith ("mkfs: used handle after closing it");
1751 const char *fstype = String_val (fstypev);
1752 const char *device = String_val (devicev);
1755 caml_enter_blocking_section ();
1756 r = guestfs_mkfs (g, fstype, device);
1757 caml_leave_blocking_section ();
1759 ocaml_guestfs_raise_error (g, "mkfs");
1766 ocaml_guestfs_sfdisk (value gv, value devicev, value cylsv, value headsv, value sectorsv, value linesv)
1768 CAMLparam5 (gv, devicev, cylsv, headsv, sectorsv);
1769 CAMLxparam1 (linesv);
1772 guestfs_h *g = Guestfs_val (gv);
1774 caml_failwith ("sfdisk: used handle after closing it");
1776 const char *device = String_val (devicev);
1777 int cyls = Int_val (cylsv);
1778 int heads = Int_val (headsv);
1779 int sectors = Int_val (sectorsv);
1780 char **lines = ocaml_guestfs_strings_val (linesv);
1783 caml_enter_blocking_section ();
1784 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1785 caml_leave_blocking_section ();
1786 ocaml_guestfs_free_strings (lines);
1788 ocaml_guestfs_raise_error (g, "sfdisk");
1795 ocaml_guestfs_sfdisk_byte (value *argv, int argn)
1797 return ocaml_guestfs_sfdisk (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4]);
1801 ocaml_guestfs_write_file (value gv, value pathv, value contentv, value sizev)
1803 CAMLparam4 (gv, pathv, contentv, sizev);
1806 guestfs_h *g = Guestfs_val (gv);
1808 caml_failwith ("write_file: used handle after closing it");
1810 const char *path = String_val (pathv);
1811 const char *content = String_val (contentv);
1812 int size = Int_val (sizev);
1815 caml_enter_blocking_section ();
1816 r = guestfs_write_file (g, path, content, size);
1817 caml_leave_blocking_section ();
1819 ocaml_guestfs_raise_error (g, "write_file");
1826 ocaml_guestfs_umount (value gv, value pathordevicev)
1828 CAMLparam2 (gv, pathordevicev);
1831 guestfs_h *g = Guestfs_val (gv);
1833 caml_failwith ("umount: used handle after closing it");
1835 const char *pathordevice = String_val (pathordevicev);
1838 caml_enter_blocking_section ();
1839 r = guestfs_umount (g, pathordevice);
1840 caml_leave_blocking_section ();
1842 ocaml_guestfs_raise_error (g, "umount");
1849 ocaml_guestfs_mounts (value gv)
1854 guestfs_h *g = Guestfs_val (gv);
1856 caml_failwith ("mounts: used handle after closing it");
1861 caml_enter_blocking_section ();
1862 r = guestfs_mounts (g);
1863 caml_leave_blocking_section ();
1865 ocaml_guestfs_raise_error (g, "mounts");
1867 rv = caml_copy_string_array ((const char **) r);
1868 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1874 ocaml_guestfs_umount_all (value gv)
1879 guestfs_h *g = Guestfs_val (gv);
1881 caml_failwith ("umount_all: used handle after closing it");
1885 caml_enter_blocking_section ();
1886 r = guestfs_umount_all (g);
1887 caml_leave_blocking_section ();
1889 ocaml_guestfs_raise_error (g, "umount_all");
1896 ocaml_guestfs_lvm_remove_all (value gv)
1901 guestfs_h *g = Guestfs_val (gv);
1903 caml_failwith ("lvm_remove_all: used handle after closing it");
1907 caml_enter_blocking_section ();
1908 r = guestfs_lvm_remove_all (g);
1909 caml_leave_blocking_section ();
1911 ocaml_guestfs_raise_error (g, "lvm_remove_all");
1918 ocaml_guestfs_file (value gv, value pathv)
1920 CAMLparam2 (gv, pathv);
1923 guestfs_h *g = Guestfs_val (gv);
1925 caml_failwith ("file: used handle after closing it");
1927 const char *path = String_val (pathv);
1930 caml_enter_blocking_section ();
1931 r = guestfs_file (g, path);
1932 caml_leave_blocking_section ();
1934 ocaml_guestfs_raise_error (g, "file");
1936 rv = caml_copy_string (r);
1942 ocaml_guestfs_command (value gv, value argumentsv)
1944 CAMLparam2 (gv, argumentsv);
1947 guestfs_h *g = Guestfs_val (gv);
1949 caml_failwith ("command: used handle after closing it");
1951 char **arguments = ocaml_guestfs_strings_val (argumentsv);
1954 caml_enter_blocking_section ();
1955 r = guestfs_command (g, arguments);
1956 caml_leave_blocking_section ();
1957 ocaml_guestfs_free_strings (arguments);
1959 ocaml_guestfs_raise_error (g, "command");
1961 rv = caml_copy_string (r);
1967 ocaml_guestfs_command_lines (value gv, value argumentsv)
1969 CAMLparam2 (gv, argumentsv);
1972 guestfs_h *g = Guestfs_val (gv);
1974 caml_failwith ("command_lines: used handle after closing it");
1976 char **arguments = ocaml_guestfs_strings_val (argumentsv);
1980 caml_enter_blocking_section ();
1981 r = guestfs_command_lines (g, arguments);
1982 caml_leave_blocking_section ();
1983 ocaml_guestfs_free_strings (arguments);
1985 ocaml_guestfs_raise_error (g, "command_lines");
1987 rv = caml_copy_string_array ((const char **) r);
1988 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1994 ocaml_guestfs_stat (value gv, value pathv)
1996 CAMLparam2 (gv, pathv);
1999 guestfs_h *g = Guestfs_val (gv);
2001 caml_failwith ("stat: used handle after closing it");
2003 const char *path = String_val (pathv);
2004 struct guestfs_stat *r;
2006 caml_enter_blocking_section ();
2007 r = guestfs_stat (g, path);
2008 caml_leave_blocking_section ();
2010 ocaml_guestfs_raise_error (g, "stat");
2018 ocaml_guestfs_lstat (value gv, value pathv)
2020 CAMLparam2 (gv, pathv);
2023 guestfs_h *g = Guestfs_val (gv);
2025 caml_failwith ("lstat: used handle after closing it");
2027 const char *path = String_val (pathv);
2028 struct guestfs_stat *r;
2030 caml_enter_blocking_section ();
2031 r = guestfs_lstat (g, path);
2032 caml_leave_blocking_section ();
2034 ocaml_guestfs_raise_error (g, "lstat");
2042 ocaml_guestfs_statvfs (value gv, value pathv)
2044 CAMLparam2 (gv, pathv);
2047 guestfs_h *g = Guestfs_val (gv);
2049 caml_failwith ("statvfs: used handle after closing it");
2051 const char *path = String_val (pathv);
2052 struct guestfs_statvfs *r;
2054 caml_enter_blocking_section ();
2055 r = guestfs_statvfs (g, path);
2056 caml_leave_blocking_section ();
2058 ocaml_guestfs_raise_error (g, "statvfs");
2060 rv = copy_statvfs (r);
2066 ocaml_guestfs_tune2fs_l (value gv, value devicev)
2068 CAMLparam2 (gv, devicev);
2071 guestfs_h *g = Guestfs_val (gv);
2073 caml_failwith ("tune2fs_l: used handle after closing it");
2075 const char *device = String_val (devicev);
2079 caml_enter_blocking_section ();
2080 r = guestfs_tune2fs_l (g, device);
2081 caml_leave_blocking_section ();
2083 ocaml_guestfs_raise_error (g, "tune2fs_l");
2085 rv = copy_table (r);
2086 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2092 ocaml_guestfs_blockdev_setro (value gv, value devicev)
2094 CAMLparam2 (gv, devicev);
2097 guestfs_h *g = Guestfs_val (gv);
2099 caml_failwith ("blockdev_setro: used handle after closing it");
2101 const char *device = String_val (devicev);
2104 caml_enter_blocking_section ();
2105 r = guestfs_blockdev_setro (g, device);
2106 caml_leave_blocking_section ();
2108 ocaml_guestfs_raise_error (g, "blockdev_setro");
2115 ocaml_guestfs_blockdev_setrw (value gv, value devicev)
2117 CAMLparam2 (gv, devicev);
2120 guestfs_h *g = Guestfs_val (gv);
2122 caml_failwith ("blockdev_setrw: used handle after closing it");
2124 const char *device = String_val (devicev);
2127 caml_enter_blocking_section ();
2128 r = guestfs_blockdev_setrw (g, device);
2129 caml_leave_blocking_section ();
2131 ocaml_guestfs_raise_error (g, "blockdev_setrw");
2138 ocaml_guestfs_blockdev_getro (value gv, value devicev)
2140 CAMLparam2 (gv, devicev);
2143 guestfs_h *g = Guestfs_val (gv);
2145 caml_failwith ("blockdev_getro: used handle after closing it");
2147 const char *device = String_val (devicev);
2150 caml_enter_blocking_section ();
2151 r = guestfs_blockdev_getro (g, device);
2152 caml_leave_blocking_section ();
2154 ocaml_guestfs_raise_error (g, "blockdev_getro");
2161 ocaml_guestfs_blockdev_getss (value gv, value devicev)
2163 CAMLparam2 (gv, devicev);
2166 guestfs_h *g = Guestfs_val (gv);
2168 caml_failwith ("blockdev_getss: used handle after closing it");
2170 const char *device = String_val (devicev);
2173 caml_enter_blocking_section ();
2174 r = guestfs_blockdev_getss (g, device);
2175 caml_leave_blocking_section ();
2177 ocaml_guestfs_raise_error (g, "blockdev_getss");
2184 ocaml_guestfs_blockdev_getbsz (value gv, value devicev)
2186 CAMLparam2 (gv, devicev);
2189 guestfs_h *g = Guestfs_val (gv);
2191 caml_failwith ("blockdev_getbsz: used handle after closing it");
2193 const char *device = String_val (devicev);
2196 caml_enter_blocking_section ();
2197 r = guestfs_blockdev_getbsz (g, device);
2198 caml_leave_blocking_section ();
2200 ocaml_guestfs_raise_error (g, "blockdev_getbsz");
2207 ocaml_guestfs_blockdev_setbsz (value gv, value devicev, value blocksizev)
2209 CAMLparam3 (gv, devicev, blocksizev);
2212 guestfs_h *g = Guestfs_val (gv);
2214 caml_failwith ("blockdev_setbsz: used handle after closing it");
2216 const char *device = String_val (devicev);
2217 int blocksize = Int_val (blocksizev);
2220 caml_enter_blocking_section ();
2221 r = guestfs_blockdev_setbsz (g, device, blocksize);
2222 caml_leave_blocking_section ();
2224 ocaml_guestfs_raise_error (g, "blockdev_setbsz");
2231 ocaml_guestfs_blockdev_getsz (value gv, value devicev)
2233 CAMLparam2 (gv, devicev);
2236 guestfs_h *g = Guestfs_val (gv);
2238 caml_failwith ("blockdev_getsz: used handle after closing it");
2240 const char *device = String_val (devicev);
2243 caml_enter_blocking_section ();
2244 r = guestfs_blockdev_getsz (g, device);
2245 caml_leave_blocking_section ();
2247 ocaml_guestfs_raise_error (g, "blockdev_getsz");
2249 rv = caml_copy_int64 (r);
2254 ocaml_guestfs_blockdev_getsize64 (value gv, value devicev)
2256 CAMLparam2 (gv, devicev);
2259 guestfs_h *g = Guestfs_val (gv);
2261 caml_failwith ("blockdev_getsize64: used handle after closing it");
2263 const char *device = String_val (devicev);
2266 caml_enter_blocking_section ();
2267 r = guestfs_blockdev_getsize64 (g, device);
2268 caml_leave_blocking_section ();
2270 ocaml_guestfs_raise_error (g, "blockdev_getsize64");
2272 rv = caml_copy_int64 (r);
2277 ocaml_guestfs_blockdev_flushbufs (value gv, value devicev)
2279 CAMLparam2 (gv, devicev);
2282 guestfs_h *g = Guestfs_val (gv);
2284 caml_failwith ("blockdev_flushbufs: used handle after closing it");
2286 const char *device = String_val (devicev);
2289 caml_enter_blocking_section ();
2290 r = guestfs_blockdev_flushbufs (g, device);
2291 caml_leave_blocking_section ();
2293 ocaml_guestfs_raise_error (g, "blockdev_flushbufs");
2300 ocaml_guestfs_blockdev_rereadpt (value gv, value devicev)
2302 CAMLparam2 (gv, devicev);
2305 guestfs_h *g = Guestfs_val (gv);
2307 caml_failwith ("blockdev_rereadpt: used handle after closing it");
2309 const char *device = String_val (devicev);
2312 caml_enter_blocking_section ();
2313 r = guestfs_blockdev_rereadpt (g, device);
2314 caml_leave_blocking_section ();
2316 ocaml_guestfs_raise_error (g, "blockdev_rereadpt");
2323 ocaml_guestfs_upload (value gv, value filenamev, value remotefilenamev)
2325 CAMLparam3 (gv, filenamev, remotefilenamev);
2328 guestfs_h *g = Guestfs_val (gv);
2330 caml_failwith ("upload: used handle after closing it");
2332 const char *filename = String_val (filenamev);
2333 const char *remotefilename = String_val (remotefilenamev);
2336 caml_enter_blocking_section ();
2337 r = guestfs_upload (g, filename, remotefilename);
2338 caml_leave_blocking_section ();
2340 ocaml_guestfs_raise_error (g, "upload");
2347 ocaml_guestfs_download (value gv, value remotefilenamev, value filenamev)
2349 CAMLparam3 (gv, remotefilenamev, filenamev);
2352 guestfs_h *g = Guestfs_val (gv);
2354 caml_failwith ("download: used handle after closing it");
2356 const char *remotefilename = String_val (remotefilenamev);
2357 const char *filename = String_val (filenamev);
2360 caml_enter_blocking_section ();
2361 r = guestfs_download (g, remotefilename, filename);
2362 caml_leave_blocking_section ();
2364 ocaml_guestfs_raise_error (g, "download");
2371 ocaml_guestfs_checksum (value gv, value csumtypev, value pathv)
2373 CAMLparam3 (gv, csumtypev, pathv);
2376 guestfs_h *g = Guestfs_val (gv);
2378 caml_failwith ("checksum: used handle after closing it");
2380 const char *csumtype = String_val (csumtypev);
2381 const char *path = String_val (pathv);
2384 caml_enter_blocking_section ();
2385 r = guestfs_checksum (g, csumtype, path);
2386 caml_leave_blocking_section ();
2388 ocaml_guestfs_raise_error (g, "checksum");
2390 rv = caml_copy_string (r);
2396 ocaml_guestfs_tar_in (value gv, value tarfilev, value directoryv)
2398 CAMLparam3 (gv, tarfilev, directoryv);
2401 guestfs_h *g = Guestfs_val (gv);
2403 caml_failwith ("tar_in: used handle after closing it");
2405 const char *tarfile = String_val (tarfilev);
2406 const char *directory = String_val (directoryv);
2409 caml_enter_blocking_section ();
2410 r = guestfs_tar_in (g, tarfile, directory);
2411 caml_leave_blocking_section ();
2413 ocaml_guestfs_raise_error (g, "tar_in");
2420 ocaml_guestfs_tar_out (value gv, value directoryv, value tarfilev)
2422 CAMLparam3 (gv, directoryv, tarfilev);
2425 guestfs_h *g = Guestfs_val (gv);
2427 caml_failwith ("tar_out: used handle after closing it");
2429 const char *directory = String_val (directoryv);
2430 const char *tarfile = String_val (tarfilev);
2433 caml_enter_blocking_section ();
2434 r = guestfs_tar_out (g, directory, tarfile);
2435 caml_leave_blocking_section ();
2437 ocaml_guestfs_raise_error (g, "tar_out");
2444 ocaml_guestfs_tgz_in (value gv, value tarballv, value directoryv)
2446 CAMLparam3 (gv, tarballv, directoryv);
2449 guestfs_h *g = Guestfs_val (gv);
2451 caml_failwith ("tgz_in: used handle after closing it");
2453 const char *tarball = String_val (tarballv);
2454 const char *directory = String_val (directoryv);
2457 caml_enter_blocking_section ();
2458 r = guestfs_tgz_in (g, tarball, directory);
2459 caml_leave_blocking_section ();
2461 ocaml_guestfs_raise_error (g, "tgz_in");
2468 ocaml_guestfs_tgz_out (value gv, value directoryv, value tarballv)
2470 CAMLparam3 (gv, directoryv, tarballv);
2473 guestfs_h *g = Guestfs_val (gv);
2475 caml_failwith ("tgz_out: used handle after closing it");
2477 const char *directory = String_val (directoryv);
2478 const char *tarball = String_val (tarballv);
2481 caml_enter_blocking_section ();
2482 r = guestfs_tgz_out (g, directory, tarball);
2483 caml_leave_blocking_section ();
2485 ocaml_guestfs_raise_error (g, "tgz_out");