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_test0 (value gv, value strv, value optstrv, value strlistv, value bv, value integerv, value fileinv, value fileoutv)
334 CAMLparam5 (gv, strv, optstrv, strlistv, bv);
335 CAMLxparam3 (integerv, fileinv, fileoutv);
338 guestfs_h *g = Guestfs_val (gv);
340 caml_failwith ("test0: used handle after closing it");
342 const char *str = String_val (strv);
344 optstrv != Val_int (0) ? String_val (Field (optstrv, 0)) : NULL;
345 char **strlist = ocaml_guestfs_strings_val (g, strlistv);
346 int b = Bool_val (bv);
347 int integer = Int_val (integerv);
348 const char *filein = String_val (fileinv);
349 const char *fileout = String_val (fileoutv);
352 caml_enter_blocking_section ();
353 r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
354 caml_leave_blocking_section ();
355 ocaml_guestfs_free_strings (strlist);
357 ocaml_guestfs_raise_error (g, "test0");
364 ocaml_guestfs_test0_byte (value *argv, int argn)
366 return ocaml_guestfs_test0 (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
370 ocaml_guestfs_test0rint (value gv, value valv)
372 CAMLparam2 (gv, valv);
375 guestfs_h *g = Guestfs_val (gv);
377 caml_failwith ("test0rint: used handle after closing it");
379 const char *val = String_val (valv);
382 caml_enter_blocking_section ();
383 r = guestfs_test0rint (g, val);
384 caml_leave_blocking_section ();
386 ocaml_guestfs_raise_error (g, "test0rint");
393 ocaml_guestfs_test0rinterr (value gv)
398 guestfs_h *g = Guestfs_val (gv);
400 caml_failwith ("test0rinterr: used handle after closing it");
404 caml_enter_blocking_section ();
405 r = guestfs_test0rinterr (g);
406 caml_leave_blocking_section ();
408 ocaml_guestfs_raise_error (g, "test0rinterr");
415 ocaml_guestfs_test0rint64 (value gv, value valv)
417 CAMLparam2 (gv, valv);
420 guestfs_h *g = Guestfs_val (gv);
422 caml_failwith ("test0rint64: used handle after closing it");
424 const char *val = String_val (valv);
427 caml_enter_blocking_section ();
428 r = guestfs_test0rint64 (g, val);
429 caml_leave_blocking_section ();
431 ocaml_guestfs_raise_error (g, "test0rint64");
433 rv = caml_copy_int64 (r);
438 ocaml_guestfs_test0rint64err (value gv)
443 guestfs_h *g = Guestfs_val (gv);
445 caml_failwith ("test0rint64err: used handle after closing it");
449 caml_enter_blocking_section ();
450 r = guestfs_test0rint64err (g);
451 caml_leave_blocking_section ();
453 ocaml_guestfs_raise_error (g, "test0rint64err");
455 rv = caml_copy_int64 (r);
460 ocaml_guestfs_test0rbool (value gv, value valv)
462 CAMLparam2 (gv, valv);
465 guestfs_h *g = Guestfs_val (gv);
467 caml_failwith ("test0rbool: used handle after closing it");
469 const char *val = String_val (valv);
472 caml_enter_blocking_section ();
473 r = guestfs_test0rbool (g, val);
474 caml_leave_blocking_section ();
476 ocaml_guestfs_raise_error (g, "test0rbool");
483 ocaml_guestfs_test0rboolerr (value gv)
488 guestfs_h *g = Guestfs_val (gv);
490 caml_failwith ("test0rboolerr: used handle after closing it");
494 caml_enter_blocking_section ();
495 r = guestfs_test0rboolerr (g);
496 caml_leave_blocking_section ();
498 ocaml_guestfs_raise_error (g, "test0rboolerr");
505 ocaml_guestfs_test0rconststring (value gv, value valv)
507 CAMLparam2 (gv, valv);
510 guestfs_h *g = Guestfs_val (gv);
512 caml_failwith ("test0rconststring: used handle after closing it");
514 const char *val = String_val (valv);
517 caml_enter_blocking_section ();
518 r = guestfs_test0rconststring (g, val);
519 caml_leave_blocking_section ();
521 ocaml_guestfs_raise_error (g, "test0rconststring");
523 rv = caml_copy_string (r);
528 ocaml_guestfs_test0rconststringerr (value gv)
533 guestfs_h *g = Guestfs_val (gv);
535 caml_failwith ("test0rconststringerr: used handle after closing it");
539 caml_enter_blocking_section ();
540 r = guestfs_test0rconststringerr (g);
541 caml_leave_blocking_section ();
543 ocaml_guestfs_raise_error (g, "test0rconststringerr");
545 rv = caml_copy_string (r);
550 ocaml_guestfs_test0rstring (value gv, value valv)
552 CAMLparam2 (gv, valv);
555 guestfs_h *g = Guestfs_val (gv);
557 caml_failwith ("test0rstring: used handle after closing it");
559 const char *val = String_val (valv);
562 caml_enter_blocking_section ();
563 r = guestfs_test0rstring (g, val);
564 caml_leave_blocking_section ();
566 ocaml_guestfs_raise_error (g, "test0rstring");
568 rv = caml_copy_string (r);
574 ocaml_guestfs_test0rstringerr (value gv)
579 guestfs_h *g = Guestfs_val (gv);
581 caml_failwith ("test0rstringerr: used handle after closing it");
585 caml_enter_blocking_section ();
586 r = guestfs_test0rstringerr (g);
587 caml_leave_blocking_section ();
589 ocaml_guestfs_raise_error (g, "test0rstringerr");
591 rv = caml_copy_string (r);
597 ocaml_guestfs_test0rstringlist (value gv, value valv)
599 CAMLparam2 (gv, valv);
602 guestfs_h *g = Guestfs_val (gv);
604 caml_failwith ("test0rstringlist: used handle after closing it");
606 const char *val = String_val (valv);
610 caml_enter_blocking_section ();
611 r = guestfs_test0rstringlist (g, val);
612 caml_leave_blocking_section ();
614 ocaml_guestfs_raise_error (g, "test0rstringlist");
616 rv = caml_copy_string_array ((const char **) r);
617 for (i = 0; r[i] != NULL; ++i) free (r[i]);
623 ocaml_guestfs_test0rstringlisterr (value gv)
628 guestfs_h *g = Guestfs_val (gv);
630 caml_failwith ("test0rstringlisterr: used handle after closing it");
635 caml_enter_blocking_section ();
636 r = guestfs_test0rstringlisterr (g);
637 caml_leave_blocking_section ();
639 ocaml_guestfs_raise_error (g, "test0rstringlisterr");
641 rv = caml_copy_string_array ((const char **) r);
642 for (i = 0; r[i] != NULL; ++i) free (r[i]);
648 ocaml_guestfs_test0rintbool (value gv, value valv)
650 CAMLparam2 (gv, valv);
653 guestfs_h *g = Guestfs_val (gv);
655 caml_failwith ("test0rintbool: used handle after closing it");
657 const char *val = String_val (valv);
658 struct guestfs_int_bool *r;
660 caml_enter_blocking_section ();
661 r = guestfs_test0rintbool (g, val);
662 caml_leave_blocking_section ();
664 ocaml_guestfs_raise_error (g, "test0rintbool");
666 rv = caml_alloc (2, 0);
667 Store_field (rv, 0, Val_int (r->i));
668 Store_field (rv, 1, Val_bool (r->b));
669 guestfs_free_int_bool (r);
674 ocaml_guestfs_test0rintboolerr (value gv)
679 guestfs_h *g = Guestfs_val (gv);
681 caml_failwith ("test0rintboolerr: used handle after closing it");
683 struct guestfs_int_bool *r;
685 caml_enter_blocking_section ();
686 r = guestfs_test0rintboolerr (g);
687 caml_leave_blocking_section ();
689 ocaml_guestfs_raise_error (g, "test0rintboolerr");
691 rv = caml_alloc (2, 0);
692 Store_field (rv, 0, Val_int (r->i));
693 Store_field (rv, 1, Val_bool (r->b));
694 guestfs_free_int_bool (r);
699 ocaml_guestfs_test0rpvlist (value gv, value valv)
701 CAMLparam2 (gv, valv);
704 guestfs_h *g = Guestfs_val (gv);
706 caml_failwith ("test0rpvlist: used handle after closing it");
708 const char *val = String_val (valv);
709 struct guestfs_lvm_pv_list *r;
711 caml_enter_blocking_section ();
712 r = guestfs_test0rpvlist (g, val);
713 caml_leave_blocking_section ();
715 ocaml_guestfs_raise_error (g, "test0rpvlist");
717 rv = copy_lvm_pv_list (r);
718 guestfs_free_lvm_pv_list (r);
723 ocaml_guestfs_test0rpvlisterr (value gv)
728 guestfs_h *g = Guestfs_val (gv);
730 caml_failwith ("test0rpvlisterr: used handle after closing it");
732 struct guestfs_lvm_pv_list *r;
734 caml_enter_blocking_section ();
735 r = guestfs_test0rpvlisterr (g);
736 caml_leave_blocking_section ();
738 ocaml_guestfs_raise_error (g, "test0rpvlisterr");
740 rv = copy_lvm_pv_list (r);
741 guestfs_free_lvm_pv_list (r);
746 ocaml_guestfs_test0rvglist (value gv, value valv)
748 CAMLparam2 (gv, valv);
751 guestfs_h *g = Guestfs_val (gv);
753 caml_failwith ("test0rvglist: used handle after closing it");
755 const char *val = String_val (valv);
756 struct guestfs_lvm_vg_list *r;
758 caml_enter_blocking_section ();
759 r = guestfs_test0rvglist (g, val);
760 caml_leave_blocking_section ();
762 ocaml_guestfs_raise_error (g, "test0rvglist");
764 rv = copy_lvm_vg_list (r);
765 guestfs_free_lvm_vg_list (r);
770 ocaml_guestfs_test0rvglisterr (value gv)
775 guestfs_h *g = Guestfs_val (gv);
777 caml_failwith ("test0rvglisterr: used handle after closing it");
779 struct guestfs_lvm_vg_list *r;
781 caml_enter_blocking_section ();
782 r = guestfs_test0rvglisterr (g);
783 caml_leave_blocking_section ();
785 ocaml_guestfs_raise_error (g, "test0rvglisterr");
787 rv = copy_lvm_vg_list (r);
788 guestfs_free_lvm_vg_list (r);
793 ocaml_guestfs_test0rlvlist (value gv, value valv)
795 CAMLparam2 (gv, valv);
798 guestfs_h *g = Guestfs_val (gv);
800 caml_failwith ("test0rlvlist: used handle after closing it");
802 const char *val = String_val (valv);
803 struct guestfs_lvm_lv_list *r;
805 caml_enter_blocking_section ();
806 r = guestfs_test0rlvlist (g, val);
807 caml_leave_blocking_section ();
809 ocaml_guestfs_raise_error (g, "test0rlvlist");
811 rv = copy_lvm_lv_list (r);
812 guestfs_free_lvm_lv_list (r);
817 ocaml_guestfs_test0rlvlisterr (value gv)
822 guestfs_h *g = Guestfs_val (gv);
824 caml_failwith ("test0rlvlisterr: used handle after closing it");
826 struct guestfs_lvm_lv_list *r;
828 caml_enter_blocking_section ();
829 r = guestfs_test0rlvlisterr (g);
830 caml_leave_blocking_section ();
832 ocaml_guestfs_raise_error (g, "test0rlvlisterr");
834 rv = copy_lvm_lv_list (r);
835 guestfs_free_lvm_lv_list (r);
840 ocaml_guestfs_test0rstat (value gv, value valv)
842 CAMLparam2 (gv, valv);
845 guestfs_h *g = Guestfs_val (gv);
847 caml_failwith ("test0rstat: used handle after closing it");
849 const char *val = String_val (valv);
850 struct guestfs_stat *r;
852 caml_enter_blocking_section ();
853 r = guestfs_test0rstat (g, val);
854 caml_leave_blocking_section ();
856 ocaml_guestfs_raise_error (g, "test0rstat");
864 ocaml_guestfs_test0rstaterr (value gv)
869 guestfs_h *g = Guestfs_val (gv);
871 caml_failwith ("test0rstaterr: used handle after closing it");
873 struct guestfs_stat *r;
875 caml_enter_blocking_section ();
876 r = guestfs_test0rstaterr (g);
877 caml_leave_blocking_section ();
879 ocaml_guestfs_raise_error (g, "test0rstaterr");
887 ocaml_guestfs_test0rstatvfs (value gv, value valv)
889 CAMLparam2 (gv, valv);
892 guestfs_h *g = Guestfs_val (gv);
894 caml_failwith ("test0rstatvfs: used handle after closing it");
896 const char *val = String_val (valv);
897 struct guestfs_statvfs *r;
899 caml_enter_blocking_section ();
900 r = guestfs_test0rstatvfs (g, val);
901 caml_leave_blocking_section ();
903 ocaml_guestfs_raise_error (g, "test0rstatvfs");
905 rv = copy_statvfs (r);
911 ocaml_guestfs_test0rstatvfserr (value gv)
916 guestfs_h *g = Guestfs_val (gv);
918 caml_failwith ("test0rstatvfserr: used handle after closing it");
920 struct guestfs_statvfs *r;
922 caml_enter_blocking_section ();
923 r = guestfs_test0rstatvfserr (g);
924 caml_leave_blocking_section ();
926 ocaml_guestfs_raise_error (g, "test0rstatvfserr");
928 rv = copy_statvfs (r);
934 ocaml_guestfs_test0rhashtable (value gv, value valv)
936 CAMLparam2 (gv, valv);
939 guestfs_h *g = Guestfs_val (gv);
941 caml_failwith ("test0rhashtable: used handle after closing it");
943 const char *val = String_val (valv);
947 caml_enter_blocking_section ();
948 r = guestfs_test0rhashtable (g, val);
949 caml_leave_blocking_section ();
951 ocaml_guestfs_raise_error (g, "test0rhashtable");
954 for (i = 0; r[i] != NULL; ++i) free (r[i]);
960 ocaml_guestfs_test0rhashtableerr (value gv)
965 guestfs_h *g = Guestfs_val (gv);
967 caml_failwith ("test0rhashtableerr: used handle after closing it");
972 caml_enter_blocking_section ();
973 r = guestfs_test0rhashtableerr (g);
974 caml_leave_blocking_section ();
976 ocaml_guestfs_raise_error (g, "test0rhashtableerr");
979 for (i = 0; r[i] != NULL; ++i) free (r[i]);
985 ocaml_guestfs_launch (value gv)
990 guestfs_h *g = Guestfs_val (gv);
992 caml_failwith ("launch: used handle after closing it");
996 caml_enter_blocking_section ();
997 r = guestfs_launch (g);
998 caml_leave_blocking_section ();
1000 ocaml_guestfs_raise_error (g, "launch");
1007 ocaml_guestfs_wait_ready (value gv)
1012 guestfs_h *g = Guestfs_val (gv);
1014 caml_failwith ("wait_ready: used handle after closing it");
1018 caml_enter_blocking_section ();
1019 r = guestfs_wait_ready (g);
1020 caml_leave_blocking_section ();
1022 ocaml_guestfs_raise_error (g, "wait_ready");
1029 ocaml_guestfs_kill_subprocess (value gv)
1034 guestfs_h *g = Guestfs_val (gv);
1036 caml_failwith ("kill_subprocess: used handle after closing it");
1040 caml_enter_blocking_section ();
1041 r = guestfs_kill_subprocess (g);
1042 caml_leave_blocking_section ();
1044 ocaml_guestfs_raise_error (g, "kill_subprocess");
1051 ocaml_guestfs_add_drive (value gv, value filenamev)
1053 CAMLparam2 (gv, filenamev);
1056 guestfs_h *g = Guestfs_val (gv);
1058 caml_failwith ("add_drive: used handle after closing it");
1060 const char *filename = String_val (filenamev);
1063 caml_enter_blocking_section ();
1064 r = guestfs_add_drive (g, filename);
1065 caml_leave_blocking_section ();
1067 ocaml_guestfs_raise_error (g, "add_drive");
1074 ocaml_guestfs_add_cdrom (value gv, value filenamev)
1076 CAMLparam2 (gv, filenamev);
1079 guestfs_h *g = Guestfs_val (gv);
1081 caml_failwith ("add_cdrom: used handle after closing it");
1083 const char *filename = String_val (filenamev);
1086 caml_enter_blocking_section ();
1087 r = guestfs_add_cdrom (g, filename);
1088 caml_leave_blocking_section ();
1090 ocaml_guestfs_raise_error (g, "add_cdrom");
1097 ocaml_guestfs_add_drive_ro (value gv, value filenamev)
1099 CAMLparam2 (gv, filenamev);
1102 guestfs_h *g = Guestfs_val (gv);
1104 caml_failwith ("add_drive_ro: used handle after closing it");
1106 const char *filename = String_val (filenamev);
1109 caml_enter_blocking_section ();
1110 r = guestfs_add_drive_ro (g, filename);
1111 caml_leave_blocking_section ();
1113 ocaml_guestfs_raise_error (g, "add_drive_ro");
1120 ocaml_guestfs_config (value gv, value qemuparamv, value qemuvaluev)
1122 CAMLparam3 (gv, qemuparamv, qemuvaluev);
1125 guestfs_h *g = Guestfs_val (gv);
1127 caml_failwith ("config: used handle after closing it");
1129 const char *qemuparam = String_val (qemuparamv);
1130 const char *qemuvalue =
1131 qemuvaluev != Val_int (0) ? String_val (Field (qemuvaluev, 0)) : NULL;
1134 caml_enter_blocking_section ();
1135 r = guestfs_config (g, qemuparam, qemuvalue);
1136 caml_leave_blocking_section ();
1138 ocaml_guestfs_raise_error (g, "config");
1145 ocaml_guestfs_set_qemu (value gv, value qemuv)
1147 CAMLparam2 (gv, qemuv);
1150 guestfs_h *g = Guestfs_val (gv);
1152 caml_failwith ("set_qemu: used handle after closing it");
1154 const char *qemu = String_val (qemuv);
1157 caml_enter_blocking_section ();
1158 r = guestfs_set_qemu (g, qemu);
1159 caml_leave_blocking_section ();
1161 ocaml_guestfs_raise_error (g, "set_qemu");
1168 ocaml_guestfs_get_qemu (value gv)
1173 guestfs_h *g = Guestfs_val (gv);
1175 caml_failwith ("get_qemu: used handle after closing it");
1179 caml_enter_blocking_section ();
1180 r = guestfs_get_qemu (g);
1181 caml_leave_blocking_section ();
1183 ocaml_guestfs_raise_error (g, "get_qemu");
1185 rv = caml_copy_string (r);
1190 ocaml_guestfs_set_path (value gv, value pathv)
1192 CAMLparam2 (gv, pathv);
1195 guestfs_h *g = Guestfs_val (gv);
1197 caml_failwith ("set_path: used handle after closing it");
1199 const char *path = String_val (pathv);
1202 caml_enter_blocking_section ();
1203 r = guestfs_set_path (g, path);
1204 caml_leave_blocking_section ();
1206 ocaml_guestfs_raise_error (g, "set_path");
1213 ocaml_guestfs_get_path (value gv)
1218 guestfs_h *g = Guestfs_val (gv);
1220 caml_failwith ("get_path: used handle after closing it");
1224 caml_enter_blocking_section ();
1225 r = guestfs_get_path (g);
1226 caml_leave_blocking_section ();
1228 ocaml_guestfs_raise_error (g, "get_path");
1230 rv = caml_copy_string (r);
1235 ocaml_guestfs_set_append (value gv, value appendv)
1237 CAMLparam2 (gv, appendv);
1240 guestfs_h *g = Guestfs_val (gv);
1242 caml_failwith ("set_append: used handle after closing it");
1244 const char *append = String_val (appendv);
1247 caml_enter_blocking_section ();
1248 r = guestfs_set_append (g, append);
1249 caml_leave_blocking_section ();
1251 ocaml_guestfs_raise_error (g, "set_append");
1258 ocaml_guestfs_get_append (value gv)
1263 guestfs_h *g = Guestfs_val (gv);
1265 caml_failwith ("get_append: used handle after closing it");
1269 caml_enter_blocking_section ();
1270 r = guestfs_get_append (g);
1271 caml_leave_blocking_section ();
1273 ocaml_guestfs_raise_error (g, "get_append");
1275 rv = caml_copy_string (r);
1280 ocaml_guestfs_set_autosync (value gv, value autosyncv)
1282 CAMLparam2 (gv, autosyncv);
1285 guestfs_h *g = Guestfs_val (gv);
1287 caml_failwith ("set_autosync: used handle after closing it");
1289 int autosync = Bool_val (autosyncv);
1292 caml_enter_blocking_section ();
1293 r = guestfs_set_autosync (g, autosync);
1294 caml_leave_blocking_section ();
1296 ocaml_guestfs_raise_error (g, "set_autosync");
1303 ocaml_guestfs_get_autosync (value gv)
1308 guestfs_h *g = Guestfs_val (gv);
1310 caml_failwith ("get_autosync: used handle after closing it");
1314 caml_enter_blocking_section ();
1315 r = guestfs_get_autosync (g);
1316 caml_leave_blocking_section ();
1318 ocaml_guestfs_raise_error (g, "get_autosync");
1325 ocaml_guestfs_set_verbose (value gv, value verbosev)
1327 CAMLparam2 (gv, verbosev);
1330 guestfs_h *g = Guestfs_val (gv);
1332 caml_failwith ("set_verbose: used handle after closing it");
1334 int verbose = Bool_val (verbosev);
1337 caml_enter_blocking_section ();
1338 r = guestfs_set_verbose (g, verbose);
1339 caml_leave_blocking_section ();
1341 ocaml_guestfs_raise_error (g, "set_verbose");
1348 ocaml_guestfs_get_verbose (value gv)
1353 guestfs_h *g = Guestfs_val (gv);
1355 caml_failwith ("get_verbose: used handle after closing it");
1359 caml_enter_blocking_section ();
1360 r = guestfs_get_verbose (g);
1361 caml_leave_blocking_section ();
1363 ocaml_guestfs_raise_error (g, "get_verbose");
1370 ocaml_guestfs_is_ready (value gv)
1375 guestfs_h *g = Guestfs_val (gv);
1377 caml_failwith ("is_ready: used handle after closing it");
1381 caml_enter_blocking_section ();
1382 r = guestfs_is_ready (g);
1383 caml_leave_blocking_section ();
1385 ocaml_guestfs_raise_error (g, "is_ready");
1392 ocaml_guestfs_is_config (value gv)
1397 guestfs_h *g = Guestfs_val (gv);
1399 caml_failwith ("is_config: used handle after closing it");
1403 caml_enter_blocking_section ();
1404 r = guestfs_is_config (g);
1405 caml_leave_blocking_section ();
1407 ocaml_guestfs_raise_error (g, "is_config");
1414 ocaml_guestfs_is_launching (value gv)
1419 guestfs_h *g = Guestfs_val (gv);
1421 caml_failwith ("is_launching: used handle after closing it");
1425 caml_enter_blocking_section ();
1426 r = guestfs_is_launching (g);
1427 caml_leave_blocking_section ();
1429 ocaml_guestfs_raise_error (g, "is_launching");
1436 ocaml_guestfs_is_busy (value gv)
1441 guestfs_h *g = Guestfs_val (gv);
1443 caml_failwith ("is_busy: used handle after closing it");
1447 caml_enter_blocking_section ();
1448 r = guestfs_is_busy (g);
1449 caml_leave_blocking_section ();
1451 ocaml_guestfs_raise_error (g, "is_busy");
1458 ocaml_guestfs_get_state (value gv)
1463 guestfs_h *g = Guestfs_val (gv);
1465 caml_failwith ("get_state: used handle after closing it");
1469 caml_enter_blocking_section ();
1470 r = guestfs_get_state (g);
1471 caml_leave_blocking_section ();
1473 ocaml_guestfs_raise_error (g, "get_state");
1480 ocaml_guestfs_set_busy (value gv)
1485 guestfs_h *g = Guestfs_val (gv);
1487 caml_failwith ("set_busy: used handle after closing it");
1491 caml_enter_blocking_section ();
1492 r = guestfs_set_busy (g);
1493 caml_leave_blocking_section ();
1495 ocaml_guestfs_raise_error (g, "set_busy");
1502 ocaml_guestfs_set_ready (value gv)
1507 guestfs_h *g = Guestfs_val (gv);
1509 caml_failwith ("set_ready: used handle after closing it");
1513 caml_enter_blocking_section ();
1514 r = guestfs_set_ready (g);
1515 caml_leave_blocking_section ();
1517 ocaml_guestfs_raise_error (g, "set_ready");
1524 ocaml_guestfs_end_busy (value gv)
1529 guestfs_h *g = Guestfs_val (gv);
1531 caml_failwith ("end_busy: used handle after closing it");
1535 caml_enter_blocking_section ();
1536 r = guestfs_end_busy (g);
1537 caml_leave_blocking_section ();
1539 ocaml_guestfs_raise_error (g, "end_busy");
1546 ocaml_guestfs_set_memsize (value gv, value memsizev)
1548 CAMLparam2 (gv, memsizev);
1551 guestfs_h *g = Guestfs_val (gv);
1553 caml_failwith ("set_memsize: used handle after closing it");
1555 int memsize = Int_val (memsizev);
1558 caml_enter_blocking_section ();
1559 r = guestfs_set_memsize (g, memsize);
1560 caml_leave_blocking_section ();
1562 ocaml_guestfs_raise_error (g, "set_memsize");
1569 ocaml_guestfs_get_memsize (value gv)
1574 guestfs_h *g = Guestfs_val (gv);
1576 caml_failwith ("get_memsize: used handle after closing it");
1580 caml_enter_blocking_section ();
1581 r = guestfs_get_memsize (g);
1582 caml_leave_blocking_section ();
1584 ocaml_guestfs_raise_error (g, "get_memsize");
1591 ocaml_guestfs_mount (value gv, value devicev, value mountpointv)
1593 CAMLparam3 (gv, devicev, mountpointv);
1596 guestfs_h *g = Guestfs_val (gv);
1598 caml_failwith ("mount: used handle after closing it");
1600 const char *device = String_val (devicev);
1601 const char *mountpoint = String_val (mountpointv);
1604 caml_enter_blocking_section ();
1605 r = guestfs_mount (g, device, mountpoint);
1606 caml_leave_blocking_section ();
1608 ocaml_guestfs_raise_error (g, "mount");
1615 ocaml_guestfs_sync (value gv)
1620 guestfs_h *g = Guestfs_val (gv);
1622 caml_failwith ("sync: used handle after closing it");
1626 caml_enter_blocking_section ();
1627 r = guestfs_sync (g);
1628 caml_leave_blocking_section ();
1630 ocaml_guestfs_raise_error (g, "sync");
1637 ocaml_guestfs_touch (value gv, value pathv)
1639 CAMLparam2 (gv, pathv);
1642 guestfs_h *g = Guestfs_val (gv);
1644 caml_failwith ("touch: used handle after closing it");
1646 const char *path = String_val (pathv);
1649 caml_enter_blocking_section ();
1650 r = guestfs_touch (g, path);
1651 caml_leave_blocking_section ();
1653 ocaml_guestfs_raise_error (g, "touch");
1660 ocaml_guestfs_cat (value gv, value pathv)
1662 CAMLparam2 (gv, pathv);
1665 guestfs_h *g = Guestfs_val (gv);
1667 caml_failwith ("cat: used handle after closing it");
1669 const char *path = String_val (pathv);
1672 caml_enter_blocking_section ();
1673 r = guestfs_cat (g, path);
1674 caml_leave_blocking_section ();
1676 ocaml_guestfs_raise_error (g, "cat");
1678 rv = caml_copy_string (r);
1684 ocaml_guestfs_ll (value gv, value directoryv)
1686 CAMLparam2 (gv, directoryv);
1689 guestfs_h *g = Guestfs_val (gv);
1691 caml_failwith ("ll: used handle after closing it");
1693 const char *directory = String_val (directoryv);
1696 caml_enter_blocking_section ();
1697 r = guestfs_ll (g, directory);
1698 caml_leave_blocking_section ();
1700 ocaml_guestfs_raise_error (g, "ll");
1702 rv = caml_copy_string (r);
1708 ocaml_guestfs_ls (value gv, value directoryv)
1710 CAMLparam2 (gv, directoryv);
1713 guestfs_h *g = Guestfs_val (gv);
1715 caml_failwith ("ls: used handle after closing it");
1717 const char *directory = String_val (directoryv);
1721 caml_enter_blocking_section ();
1722 r = guestfs_ls (g, directory);
1723 caml_leave_blocking_section ();
1725 ocaml_guestfs_raise_error (g, "ls");
1727 rv = caml_copy_string_array ((const char **) r);
1728 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1734 ocaml_guestfs_list_devices (value gv)
1739 guestfs_h *g = Guestfs_val (gv);
1741 caml_failwith ("list_devices: used handle after closing it");
1746 caml_enter_blocking_section ();
1747 r = guestfs_list_devices (g);
1748 caml_leave_blocking_section ();
1750 ocaml_guestfs_raise_error (g, "list_devices");
1752 rv = caml_copy_string_array ((const char **) r);
1753 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1759 ocaml_guestfs_list_partitions (value gv)
1764 guestfs_h *g = Guestfs_val (gv);
1766 caml_failwith ("list_partitions: used handle after closing it");
1771 caml_enter_blocking_section ();
1772 r = guestfs_list_partitions (g);
1773 caml_leave_blocking_section ();
1775 ocaml_guestfs_raise_error (g, "list_partitions");
1777 rv = caml_copy_string_array ((const char **) r);
1778 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1784 ocaml_guestfs_pvs (value gv)
1789 guestfs_h *g = Guestfs_val (gv);
1791 caml_failwith ("pvs: used handle after closing it");
1796 caml_enter_blocking_section ();
1797 r = guestfs_pvs (g);
1798 caml_leave_blocking_section ();
1800 ocaml_guestfs_raise_error (g, "pvs");
1802 rv = caml_copy_string_array ((const char **) r);
1803 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1809 ocaml_guestfs_vgs (value gv)
1814 guestfs_h *g = Guestfs_val (gv);
1816 caml_failwith ("vgs: used handle after closing it");
1821 caml_enter_blocking_section ();
1822 r = guestfs_vgs (g);
1823 caml_leave_blocking_section ();
1825 ocaml_guestfs_raise_error (g, "vgs");
1827 rv = caml_copy_string_array ((const char **) r);
1828 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1834 ocaml_guestfs_lvs (value gv)
1839 guestfs_h *g = Guestfs_val (gv);
1841 caml_failwith ("lvs: used handle after closing it");
1846 caml_enter_blocking_section ();
1847 r = guestfs_lvs (g);
1848 caml_leave_blocking_section ();
1850 ocaml_guestfs_raise_error (g, "lvs");
1852 rv = caml_copy_string_array ((const char **) r);
1853 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1859 ocaml_guestfs_pvs_full (value gv)
1864 guestfs_h *g = Guestfs_val (gv);
1866 caml_failwith ("pvs_full: used handle after closing it");
1868 struct guestfs_lvm_pv_list *r;
1870 caml_enter_blocking_section ();
1871 r = guestfs_pvs_full (g);
1872 caml_leave_blocking_section ();
1874 ocaml_guestfs_raise_error (g, "pvs_full");
1876 rv = copy_lvm_pv_list (r);
1877 guestfs_free_lvm_pv_list (r);
1882 ocaml_guestfs_vgs_full (value gv)
1887 guestfs_h *g = Guestfs_val (gv);
1889 caml_failwith ("vgs_full: used handle after closing it");
1891 struct guestfs_lvm_vg_list *r;
1893 caml_enter_blocking_section ();
1894 r = guestfs_vgs_full (g);
1895 caml_leave_blocking_section ();
1897 ocaml_guestfs_raise_error (g, "vgs_full");
1899 rv = copy_lvm_vg_list (r);
1900 guestfs_free_lvm_vg_list (r);
1905 ocaml_guestfs_lvs_full (value gv)
1910 guestfs_h *g = Guestfs_val (gv);
1912 caml_failwith ("lvs_full: used handle after closing it");
1914 struct guestfs_lvm_lv_list *r;
1916 caml_enter_blocking_section ();
1917 r = guestfs_lvs_full (g);
1918 caml_leave_blocking_section ();
1920 ocaml_guestfs_raise_error (g, "lvs_full");
1922 rv = copy_lvm_lv_list (r);
1923 guestfs_free_lvm_lv_list (r);
1928 ocaml_guestfs_read_lines (value gv, value pathv)
1930 CAMLparam2 (gv, pathv);
1933 guestfs_h *g = Guestfs_val (gv);
1935 caml_failwith ("read_lines: used handle after closing it");
1937 const char *path = String_val (pathv);
1941 caml_enter_blocking_section ();
1942 r = guestfs_read_lines (g, path);
1943 caml_leave_blocking_section ();
1945 ocaml_guestfs_raise_error (g, "read_lines");
1947 rv = caml_copy_string_array ((const char **) r);
1948 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1954 ocaml_guestfs_aug_init (value gv, value rootv, value flagsv)
1956 CAMLparam3 (gv, rootv, flagsv);
1959 guestfs_h *g = Guestfs_val (gv);
1961 caml_failwith ("aug_init: used handle after closing it");
1963 const char *root = String_val (rootv);
1964 int flags = Int_val (flagsv);
1967 caml_enter_blocking_section ();
1968 r = guestfs_aug_init (g, root, flags);
1969 caml_leave_blocking_section ();
1971 ocaml_guestfs_raise_error (g, "aug_init");
1978 ocaml_guestfs_aug_close (value gv)
1983 guestfs_h *g = Guestfs_val (gv);
1985 caml_failwith ("aug_close: used handle after closing it");
1989 caml_enter_blocking_section ();
1990 r = guestfs_aug_close (g);
1991 caml_leave_blocking_section ();
1993 ocaml_guestfs_raise_error (g, "aug_close");
2000 ocaml_guestfs_aug_defvar (value gv, value namev, value exprv)
2002 CAMLparam3 (gv, namev, exprv);
2005 guestfs_h *g = Guestfs_val (gv);
2007 caml_failwith ("aug_defvar: used handle after closing it");
2009 const char *name = String_val (namev);
2011 exprv != Val_int (0) ? String_val (Field (exprv, 0)) : NULL;
2014 caml_enter_blocking_section ();
2015 r = guestfs_aug_defvar (g, name, expr);
2016 caml_leave_blocking_section ();
2018 ocaml_guestfs_raise_error (g, "aug_defvar");
2025 ocaml_guestfs_aug_defnode (value gv, value namev, value exprv, value valv)
2027 CAMLparam4 (gv, namev, exprv, valv);
2030 guestfs_h *g = Guestfs_val (gv);
2032 caml_failwith ("aug_defnode: used handle after closing it");
2034 const char *name = String_val (namev);
2035 const char *expr = String_val (exprv);
2036 const char *val = String_val (valv);
2037 struct guestfs_int_bool *r;
2039 caml_enter_blocking_section ();
2040 r = guestfs_aug_defnode (g, name, expr, val);
2041 caml_leave_blocking_section ();
2043 ocaml_guestfs_raise_error (g, "aug_defnode");
2045 rv = caml_alloc (2, 0);
2046 Store_field (rv, 0, Val_int (r->i));
2047 Store_field (rv, 1, Val_bool (r->b));
2048 guestfs_free_int_bool (r);
2053 ocaml_guestfs_aug_get (value gv, value pathv)
2055 CAMLparam2 (gv, pathv);
2058 guestfs_h *g = Guestfs_val (gv);
2060 caml_failwith ("aug_get: used handle after closing it");
2062 const char *path = String_val (pathv);
2065 caml_enter_blocking_section ();
2066 r = guestfs_aug_get (g, path);
2067 caml_leave_blocking_section ();
2069 ocaml_guestfs_raise_error (g, "aug_get");
2071 rv = caml_copy_string (r);
2077 ocaml_guestfs_aug_set (value gv, value pathv, value valv)
2079 CAMLparam3 (gv, pathv, valv);
2082 guestfs_h *g = Guestfs_val (gv);
2084 caml_failwith ("aug_set: used handle after closing it");
2086 const char *path = String_val (pathv);
2087 const char *val = String_val (valv);
2090 caml_enter_blocking_section ();
2091 r = guestfs_aug_set (g, path, val);
2092 caml_leave_blocking_section ();
2094 ocaml_guestfs_raise_error (g, "aug_set");
2101 ocaml_guestfs_aug_insert (value gv, value pathv, value labelv, value beforev)
2103 CAMLparam4 (gv, pathv, labelv, beforev);
2106 guestfs_h *g = Guestfs_val (gv);
2108 caml_failwith ("aug_insert: used handle after closing it");
2110 const char *path = String_val (pathv);
2111 const char *label = String_val (labelv);
2112 int before = Bool_val (beforev);
2115 caml_enter_blocking_section ();
2116 r = guestfs_aug_insert (g, path, label, before);
2117 caml_leave_blocking_section ();
2119 ocaml_guestfs_raise_error (g, "aug_insert");
2126 ocaml_guestfs_aug_rm (value gv, value pathv)
2128 CAMLparam2 (gv, pathv);
2131 guestfs_h *g = Guestfs_val (gv);
2133 caml_failwith ("aug_rm: used handle after closing it");
2135 const char *path = String_val (pathv);
2138 caml_enter_blocking_section ();
2139 r = guestfs_aug_rm (g, path);
2140 caml_leave_blocking_section ();
2142 ocaml_guestfs_raise_error (g, "aug_rm");
2149 ocaml_guestfs_aug_mv (value gv, value srcv, value destv)
2151 CAMLparam3 (gv, srcv, destv);
2154 guestfs_h *g = Guestfs_val (gv);
2156 caml_failwith ("aug_mv: used handle after closing it");
2158 const char *src = String_val (srcv);
2159 const char *dest = String_val (destv);
2162 caml_enter_blocking_section ();
2163 r = guestfs_aug_mv (g, src, dest);
2164 caml_leave_blocking_section ();
2166 ocaml_guestfs_raise_error (g, "aug_mv");
2173 ocaml_guestfs_aug_match (value gv, value pathv)
2175 CAMLparam2 (gv, pathv);
2178 guestfs_h *g = Guestfs_val (gv);
2180 caml_failwith ("aug_match: used handle after closing it");
2182 const char *path = String_val (pathv);
2186 caml_enter_blocking_section ();
2187 r = guestfs_aug_match (g, path);
2188 caml_leave_blocking_section ();
2190 ocaml_guestfs_raise_error (g, "aug_match");
2192 rv = caml_copy_string_array ((const char **) r);
2193 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2199 ocaml_guestfs_aug_save (value gv)
2204 guestfs_h *g = Guestfs_val (gv);
2206 caml_failwith ("aug_save: used handle after closing it");
2210 caml_enter_blocking_section ();
2211 r = guestfs_aug_save (g);
2212 caml_leave_blocking_section ();
2214 ocaml_guestfs_raise_error (g, "aug_save");
2221 ocaml_guestfs_aug_load (value gv)
2226 guestfs_h *g = Guestfs_val (gv);
2228 caml_failwith ("aug_load: used handle after closing it");
2232 caml_enter_blocking_section ();
2233 r = guestfs_aug_load (g);
2234 caml_leave_blocking_section ();
2236 ocaml_guestfs_raise_error (g, "aug_load");
2243 ocaml_guestfs_aug_ls (value gv, value pathv)
2245 CAMLparam2 (gv, pathv);
2248 guestfs_h *g = Guestfs_val (gv);
2250 caml_failwith ("aug_ls: used handle after closing it");
2252 const char *path = String_val (pathv);
2256 caml_enter_blocking_section ();
2257 r = guestfs_aug_ls (g, path);
2258 caml_leave_blocking_section ();
2260 ocaml_guestfs_raise_error (g, "aug_ls");
2262 rv = caml_copy_string_array ((const char **) r);
2263 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2269 ocaml_guestfs_rm (value gv, value pathv)
2271 CAMLparam2 (gv, pathv);
2274 guestfs_h *g = Guestfs_val (gv);
2276 caml_failwith ("rm: used handle after closing it");
2278 const char *path = String_val (pathv);
2281 caml_enter_blocking_section ();
2282 r = guestfs_rm (g, path);
2283 caml_leave_blocking_section ();
2285 ocaml_guestfs_raise_error (g, "rm");
2292 ocaml_guestfs_rmdir (value gv, value pathv)
2294 CAMLparam2 (gv, pathv);
2297 guestfs_h *g = Guestfs_val (gv);
2299 caml_failwith ("rmdir: used handle after closing it");
2301 const char *path = String_val (pathv);
2304 caml_enter_blocking_section ();
2305 r = guestfs_rmdir (g, path);
2306 caml_leave_blocking_section ();
2308 ocaml_guestfs_raise_error (g, "rmdir");
2315 ocaml_guestfs_rm_rf (value gv, value pathv)
2317 CAMLparam2 (gv, pathv);
2320 guestfs_h *g = Guestfs_val (gv);
2322 caml_failwith ("rm_rf: used handle after closing it");
2324 const char *path = String_val (pathv);
2327 caml_enter_blocking_section ();
2328 r = guestfs_rm_rf (g, path);
2329 caml_leave_blocking_section ();
2331 ocaml_guestfs_raise_error (g, "rm_rf");
2338 ocaml_guestfs_mkdir (value gv, value pathv)
2340 CAMLparam2 (gv, pathv);
2343 guestfs_h *g = Guestfs_val (gv);
2345 caml_failwith ("mkdir: used handle after closing it");
2347 const char *path = String_val (pathv);
2350 caml_enter_blocking_section ();
2351 r = guestfs_mkdir (g, path);
2352 caml_leave_blocking_section ();
2354 ocaml_guestfs_raise_error (g, "mkdir");
2361 ocaml_guestfs_mkdir_p (value gv, value pathv)
2363 CAMLparam2 (gv, pathv);
2366 guestfs_h *g = Guestfs_val (gv);
2368 caml_failwith ("mkdir_p: used handle after closing it");
2370 const char *path = String_val (pathv);
2373 caml_enter_blocking_section ();
2374 r = guestfs_mkdir_p (g, path);
2375 caml_leave_blocking_section ();
2377 ocaml_guestfs_raise_error (g, "mkdir_p");
2384 ocaml_guestfs_chmod (value gv, value modev, value pathv)
2386 CAMLparam3 (gv, modev, pathv);
2389 guestfs_h *g = Guestfs_val (gv);
2391 caml_failwith ("chmod: used handle after closing it");
2393 int mode = Int_val (modev);
2394 const char *path = String_val (pathv);
2397 caml_enter_blocking_section ();
2398 r = guestfs_chmod (g, mode, path);
2399 caml_leave_blocking_section ();
2401 ocaml_guestfs_raise_error (g, "chmod");
2408 ocaml_guestfs_chown (value gv, value ownerv, value groupv, value pathv)
2410 CAMLparam4 (gv, ownerv, groupv, pathv);
2413 guestfs_h *g = Guestfs_val (gv);
2415 caml_failwith ("chown: used handle after closing it");
2417 int owner = Int_val (ownerv);
2418 int group = Int_val (groupv);
2419 const char *path = String_val (pathv);
2422 caml_enter_blocking_section ();
2423 r = guestfs_chown (g, owner, group, path);
2424 caml_leave_blocking_section ();
2426 ocaml_guestfs_raise_error (g, "chown");
2433 ocaml_guestfs_exists (value gv, value pathv)
2435 CAMLparam2 (gv, pathv);
2438 guestfs_h *g = Guestfs_val (gv);
2440 caml_failwith ("exists: used handle after closing it");
2442 const char *path = String_val (pathv);
2445 caml_enter_blocking_section ();
2446 r = guestfs_exists (g, path);
2447 caml_leave_blocking_section ();
2449 ocaml_guestfs_raise_error (g, "exists");
2456 ocaml_guestfs_is_file (value gv, value pathv)
2458 CAMLparam2 (gv, pathv);
2461 guestfs_h *g = Guestfs_val (gv);
2463 caml_failwith ("is_file: used handle after closing it");
2465 const char *path = String_val (pathv);
2468 caml_enter_blocking_section ();
2469 r = guestfs_is_file (g, path);
2470 caml_leave_blocking_section ();
2472 ocaml_guestfs_raise_error (g, "is_file");
2479 ocaml_guestfs_is_dir (value gv, value pathv)
2481 CAMLparam2 (gv, pathv);
2484 guestfs_h *g = Guestfs_val (gv);
2486 caml_failwith ("is_dir: used handle after closing it");
2488 const char *path = String_val (pathv);
2491 caml_enter_blocking_section ();
2492 r = guestfs_is_dir (g, path);
2493 caml_leave_blocking_section ();
2495 ocaml_guestfs_raise_error (g, "is_dir");
2502 ocaml_guestfs_pvcreate (value gv, value devicev)
2504 CAMLparam2 (gv, devicev);
2507 guestfs_h *g = Guestfs_val (gv);
2509 caml_failwith ("pvcreate: used handle after closing it");
2511 const char *device = String_val (devicev);
2514 caml_enter_blocking_section ();
2515 r = guestfs_pvcreate (g, device);
2516 caml_leave_blocking_section ();
2518 ocaml_guestfs_raise_error (g, "pvcreate");
2525 ocaml_guestfs_vgcreate (value gv, value volgroupv, value physvolsv)
2527 CAMLparam3 (gv, volgroupv, physvolsv);
2530 guestfs_h *g = Guestfs_val (gv);
2532 caml_failwith ("vgcreate: used handle after closing it");
2534 const char *volgroup = String_val (volgroupv);
2535 char **physvols = ocaml_guestfs_strings_val (g, physvolsv);
2538 caml_enter_blocking_section ();
2539 r = guestfs_vgcreate (g, volgroup, physvols);
2540 caml_leave_blocking_section ();
2541 ocaml_guestfs_free_strings (physvols);
2543 ocaml_guestfs_raise_error (g, "vgcreate");
2550 ocaml_guestfs_lvcreate (value gv, value logvolv, value volgroupv, value mbytesv)
2552 CAMLparam4 (gv, logvolv, volgroupv, mbytesv);
2555 guestfs_h *g = Guestfs_val (gv);
2557 caml_failwith ("lvcreate: used handle after closing it");
2559 const char *logvol = String_val (logvolv);
2560 const char *volgroup = String_val (volgroupv);
2561 int mbytes = Int_val (mbytesv);
2564 caml_enter_blocking_section ();
2565 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2566 caml_leave_blocking_section ();
2568 ocaml_guestfs_raise_error (g, "lvcreate");
2575 ocaml_guestfs_mkfs (value gv, value fstypev, value devicev)
2577 CAMLparam3 (gv, fstypev, devicev);
2580 guestfs_h *g = Guestfs_val (gv);
2582 caml_failwith ("mkfs: used handle after closing it");
2584 const char *fstype = String_val (fstypev);
2585 const char *device = String_val (devicev);
2588 caml_enter_blocking_section ();
2589 r = guestfs_mkfs (g, fstype, device);
2590 caml_leave_blocking_section ();
2592 ocaml_guestfs_raise_error (g, "mkfs");
2599 ocaml_guestfs_sfdisk (value gv, value devicev, value cylsv, value headsv, value sectorsv, value linesv)
2601 CAMLparam5 (gv, devicev, cylsv, headsv, sectorsv);
2602 CAMLxparam1 (linesv);
2605 guestfs_h *g = Guestfs_val (gv);
2607 caml_failwith ("sfdisk: used handle after closing it");
2609 const char *device = String_val (devicev);
2610 int cyls = Int_val (cylsv);
2611 int heads = Int_val (headsv);
2612 int sectors = Int_val (sectorsv);
2613 char **lines = ocaml_guestfs_strings_val (g, linesv);
2616 caml_enter_blocking_section ();
2617 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2618 caml_leave_blocking_section ();
2619 ocaml_guestfs_free_strings (lines);
2621 ocaml_guestfs_raise_error (g, "sfdisk");
2628 ocaml_guestfs_sfdisk_byte (value *argv, int argn)
2630 return ocaml_guestfs_sfdisk (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4]);
2634 ocaml_guestfs_write_file (value gv, value pathv, value contentv, value sizev)
2636 CAMLparam4 (gv, pathv, contentv, sizev);
2639 guestfs_h *g = Guestfs_val (gv);
2641 caml_failwith ("write_file: used handle after closing it");
2643 const char *path = String_val (pathv);
2644 const char *content = String_val (contentv);
2645 int size = Int_val (sizev);
2648 caml_enter_blocking_section ();
2649 r = guestfs_write_file (g, path, content, size);
2650 caml_leave_blocking_section ();
2652 ocaml_guestfs_raise_error (g, "write_file");
2659 ocaml_guestfs_umount (value gv, value pathordevicev)
2661 CAMLparam2 (gv, pathordevicev);
2664 guestfs_h *g = Guestfs_val (gv);
2666 caml_failwith ("umount: used handle after closing it");
2668 const char *pathordevice = String_val (pathordevicev);
2671 caml_enter_blocking_section ();
2672 r = guestfs_umount (g, pathordevice);
2673 caml_leave_blocking_section ();
2675 ocaml_guestfs_raise_error (g, "umount");
2682 ocaml_guestfs_mounts (value gv)
2687 guestfs_h *g = Guestfs_val (gv);
2689 caml_failwith ("mounts: used handle after closing it");
2694 caml_enter_blocking_section ();
2695 r = guestfs_mounts (g);
2696 caml_leave_blocking_section ();
2698 ocaml_guestfs_raise_error (g, "mounts");
2700 rv = caml_copy_string_array ((const char **) r);
2701 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2707 ocaml_guestfs_umount_all (value gv)
2712 guestfs_h *g = Guestfs_val (gv);
2714 caml_failwith ("umount_all: used handle after closing it");
2718 caml_enter_blocking_section ();
2719 r = guestfs_umount_all (g);
2720 caml_leave_blocking_section ();
2722 ocaml_guestfs_raise_error (g, "umount_all");
2729 ocaml_guestfs_lvm_remove_all (value gv)
2734 guestfs_h *g = Guestfs_val (gv);
2736 caml_failwith ("lvm_remove_all: used handle after closing it");
2740 caml_enter_blocking_section ();
2741 r = guestfs_lvm_remove_all (g);
2742 caml_leave_blocking_section ();
2744 ocaml_guestfs_raise_error (g, "lvm_remove_all");
2751 ocaml_guestfs_file (value gv, value pathv)
2753 CAMLparam2 (gv, pathv);
2756 guestfs_h *g = Guestfs_val (gv);
2758 caml_failwith ("file: used handle after closing it");
2760 const char *path = String_val (pathv);
2763 caml_enter_blocking_section ();
2764 r = guestfs_file (g, path);
2765 caml_leave_blocking_section ();
2767 ocaml_guestfs_raise_error (g, "file");
2769 rv = caml_copy_string (r);
2775 ocaml_guestfs_command (value gv, value argumentsv)
2777 CAMLparam2 (gv, argumentsv);
2780 guestfs_h *g = Guestfs_val (gv);
2782 caml_failwith ("command: used handle after closing it");
2784 char **arguments = ocaml_guestfs_strings_val (g, argumentsv);
2787 caml_enter_blocking_section ();
2788 r = guestfs_command (g, arguments);
2789 caml_leave_blocking_section ();
2790 ocaml_guestfs_free_strings (arguments);
2792 ocaml_guestfs_raise_error (g, "command");
2794 rv = caml_copy_string (r);
2800 ocaml_guestfs_command_lines (value gv, value argumentsv)
2802 CAMLparam2 (gv, argumentsv);
2805 guestfs_h *g = Guestfs_val (gv);
2807 caml_failwith ("command_lines: used handle after closing it");
2809 char **arguments = ocaml_guestfs_strings_val (g, argumentsv);
2813 caml_enter_blocking_section ();
2814 r = guestfs_command_lines (g, arguments);
2815 caml_leave_blocking_section ();
2816 ocaml_guestfs_free_strings (arguments);
2818 ocaml_guestfs_raise_error (g, "command_lines");
2820 rv = caml_copy_string_array ((const char **) r);
2821 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2827 ocaml_guestfs_stat (value gv, value pathv)
2829 CAMLparam2 (gv, pathv);
2832 guestfs_h *g = Guestfs_val (gv);
2834 caml_failwith ("stat: used handle after closing it");
2836 const char *path = String_val (pathv);
2837 struct guestfs_stat *r;
2839 caml_enter_blocking_section ();
2840 r = guestfs_stat (g, path);
2841 caml_leave_blocking_section ();
2843 ocaml_guestfs_raise_error (g, "stat");
2851 ocaml_guestfs_lstat (value gv, value pathv)
2853 CAMLparam2 (gv, pathv);
2856 guestfs_h *g = Guestfs_val (gv);
2858 caml_failwith ("lstat: used handle after closing it");
2860 const char *path = String_val (pathv);
2861 struct guestfs_stat *r;
2863 caml_enter_blocking_section ();
2864 r = guestfs_lstat (g, path);
2865 caml_leave_blocking_section ();
2867 ocaml_guestfs_raise_error (g, "lstat");
2875 ocaml_guestfs_statvfs (value gv, value pathv)
2877 CAMLparam2 (gv, pathv);
2880 guestfs_h *g = Guestfs_val (gv);
2882 caml_failwith ("statvfs: used handle after closing it");
2884 const char *path = String_val (pathv);
2885 struct guestfs_statvfs *r;
2887 caml_enter_blocking_section ();
2888 r = guestfs_statvfs (g, path);
2889 caml_leave_blocking_section ();
2891 ocaml_guestfs_raise_error (g, "statvfs");
2893 rv = copy_statvfs (r);
2899 ocaml_guestfs_tune2fs_l (value gv, value devicev)
2901 CAMLparam2 (gv, devicev);
2904 guestfs_h *g = Guestfs_val (gv);
2906 caml_failwith ("tune2fs_l: used handle after closing it");
2908 const char *device = String_val (devicev);
2912 caml_enter_blocking_section ();
2913 r = guestfs_tune2fs_l (g, device);
2914 caml_leave_blocking_section ();
2916 ocaml_guestfs_raise_error (g, "tune2fs_l");
2918 rv = copy_table (r);
2919 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2925 ocaml_guestfs_blockdev_setro (value gv, value devicev)
2927 CAMLparam2 (gv, devicev);
2930 guestfs_h *g = Guestfs_val (gv);
2932 caml_failwith ("blockdev_setro: used handle after closing it");
2934 const char *device = String_val (devicev);
2937 caml_enter_blocking_section ();
2938 r = guestfs_blockdev_setro (g, device);
2939 caml_leave_blocking_section ();
2941 ocaml_guestfs_raise_error (g, "blockdev_setro");
2948 ocaml_guestfs_blockdev_setrw (value gv, value devicev)
2950 CAMLparam2 (gv, devicev);
2953 guestfs_h *g = Guestfs_val (gv);
2955 caml_failwith ("blockdev_setrw: used handle after closing it");
2957 const char *device = String_val (devicev);
2960 caml_enter_blocking_section ();
2961 r = guestfs_blockdev_setrw (g, device);
2962 caml_leave_blocking_section ();
2964 ocaml_guestfs_raise_error (g, "blockdev_setrw");
2971 ocaml_guestfs_blockdev_getro (value gv, value devicev)
2973 CAMLparam2 (gv, devicev);
2976 guestfs_h *g = Guestfs_val (gv);
2978 caml_failwith ("blockdev_getro: used handle after closing it");
2980 const char *device = String_val (devicev);
2983 caml_enter_blocking_section ();
2984 r = guestfs_blockdev_getro (g, device);
2985 caml_leave_blocking_section ();
2987 ocaml_guestfs_raise_error (g, "blockdev_getro");
2994 ocaml_guestfs_blockdev_getss (value gv, value devicev)
2996 CAMLparam2 (gv, devicev);
2999 guestfs_h *g = Guestfs_val (gv);
3001 caml_failwith ("blockdev_getss: used handle after closing it");
3003 const char *device = String_val (devicev);
3006 caml_enter_blocking_section ();
3007 r = guestfs_blockdev_getss (g, device);
3008 caml_leave_blocking_section ();
3010 ocaml_guestfs_raise_error (g, "blockdev_getss");
3017 ocaml_guestfs_blockdev_getbsz (value gv, value devicev)
3019 CAMLparam2 (gv, devicev);
3022 guestfs_h *g = Guestfs_val (gv);
3024 caml_failwith ("blockdev_getbsz: used handle after closing it");
3026 const char *device = String_val (devicev);
3029 caml_enter_blocking_section ();
3030 r = guestfs_blockdev_getbsz (g, device);
3031 caml_leave_blocking_section ();
3033 ocaml_guestfs_raise_error (g, "blockdev_getbsz");
3040 ocaml_guestfs_blockdev_setbsz (value gv, value devicev, value blocksizev)
3042 CAMLparam3 (gv, devicev, blocksizev);
3045 guestfs_h *g = Guestfs_val (gv);
3047 caml_failwith ("blockdev_setbsz: used handle after closing it");
3049 const char *device = String_val (devicev);
3050 int blocksize = Int_val (blocksizev);
3053 caml_enter_blocking_section ();
3054 r = guestfs_blockdev_setbsz (g, device, blocksize);
3055 caml_leave_blocking_section ();
3057 ocaml_guestfs_raise_error (g, "blockdev_setbsz");
3064 ocaml_guestfs_blockdev_getsz (value gv, value devicev)
3066 CAMLparam2 (gv, devicev);
3069 guestfs_h *g = Guestfs_val (gv);
3071 caml_failwith ("blockdev_getsz: used handle after closing it");
3073 const char *device = String_val (devicev);
3076 caml_enter_blocking_section ();
3077 r = guestfs_blockdev_getsz (g, device);
3078 caml_leave_blocking_section ();
3080 ocaml_guestfs_raise_error (g, "blockdev_getsz");
3082 rv = caml_copy_int64 (r);
3087 ocaml_guestfs_blockdev_getsize64 (value gv, value devicev)
3089 CAMLparam2 (gv, devicev);
3092 guestfs_h *g = Guestfs_val (gv);
3094 caml_failwith ("blockdev_getsize64: used handle after closing it");
3096 const char *device = String_val (devicev);
3099 caml_enter_blocking_section ();
3100 r = guestfs_blockdev_getsize64 (g, device);
3101 caml_leave_blocking_section ();
3103 ocaml_guestfs_raise_error (g, "blockdev_getsize64");
3105 rv = caml_copy_int64 (r);
3110 ocaml_guestfs_blockdev_flushbufs (value gv, value devicev)
3112 CAMLparam2 (gv, devicev);
3115 guestfs_h *g = Guestfs_val (gv);
3117 caml_failwith ("blockdev_flushbufs: used handle after closing it");
3119 const char *device = String_val (devicev);
3122 caml_enter_blocking_section ();
3123 r = guestfs_blockdev_flushbufs (g, device);
3124 caml_leave_blocking_section ();
3126 ocaml_guestfs_raise_error (g, "blockdev_flushbufs");
3133 ocaml_guestfs_blockdev_rereadpt (value gv, value devicev)
3135 CAMLparam2 (gv, devicev);
3138 guestfs_h *g = Guestfs_val (gv);
3140 caml_failwith ("blockdev_rereadpt: used handle after closing it");
3142 const char *device = String_val (devicev);
3145 caml_enter_blocking_section ();
3146 r = guestfs_blockdev_rereadpt (g, device);
3147 caml_leave_blocking_section ();
3149 ocaml_guestfs_raise_error (g, "blockdev_rereadpt");
3156 ocaml_guestfs_upload (value gv, value filenamev, value remotefilenamev)
3158 CAMLparam3 (gv, filenamev, remotefilenamev);
3161 guestfs_h *g = Guestfs_val (gv);
3163 caml_failwith ("upload: used handle after closing it");
3165 const char *filename = String_val (filenamev);
3166 const char *remotefilename = String_val (remotefilenamev);
3169 caml_enter_blocking_section ();
3170 r = guestfs_upload (g, filename, remotefilename);
3171 caml_leave_blocking_section ();
3173 ocaml_guestfs_raise_error (g, "upload");
3180 ocaml_guestfs_download (value gv, value remotefilenamev, value filenamev)
3182 CAMLparam3 (gv, remotefilenamev, filenamev);
3185 guestfs_h *g = Guestfs_val (gv);
3187 caml_failwith ("download: used handle after closing it");
3189 const char *remotefilename = String_val (remotefilenamev);
3190 const char *filename = String_val (filenamev);
3193 caml_enter_blocking_section ();
3194 r = guestfs_download (g, remotefilename, filename);
3195 caml_leave_blocking_section ();
3197 ocaml_guestfs_raise_error (g, "download");
3204 ocaml_guestfs_checksum (value gv, value csumtypev, value pathv)
3206 CAMLparam3 (gv, csumtypev, pathv);
3209 guestfs_h *g = Guestfs_val (gv);
3211 caml_failwith ("checksum: used handle after closing it");
3213 const char *csumtype = String_val (csumtypev);
3214 const char *path = String_val (pathv);
3217 caml_enter_blocking_section ();
3218 r = guestfs_checksum (g, csumtype, path);
3219 caml_leave_blocking_section ();
3221 ocaml_guestfs_raise_error (g, "checksum");
3223 rv = caml_copy_string (r);
3229 ocaml_guestfs_tar_in (value gv, value tarfilev, value directoryv)
3231 CAMLparam3 (gv, tarfilev, directoryv);
3234 guestfs_h *g = Guestfs_val (gv);
3236 caml_failwith ("tar_in: used handle after closing it");
3238 const char *tarfile = String_val (tarfilev);
3239 const char *directory = String_val (directoryv);
3242 caml_enter_blocking_section ();
3243 r = guestfs_tar_in (g, tarfile, directory);
3244 caml_leave_blocking_section ();
3246 ocaml_guestfs_raise_error (g, "tar_in");
3253 ocaml_guestfs_tar_out (value gv, value directoryv, value tarfilev)
3255 CAMLparam3 (gv, directoryv, tarfilev);
3258 guestfs_h *g = Guestfs_val (gv);
3260 caml_failwith ("tar_out: used handle after closing it");
3262 const char *directory = String_val (directoryv);
3263 const char *tarfile = String_val (tarfilev);
3266 caml_enter_blocking_section ();
3267 r = guestfs_tar_out (g, directory, tarfile);
3268 caml_leave_blocking_section ();
3270 ocaml_guestfs_raise_error (g, "tar_out");
3277 ocaml_guestfs_tgz_in (value gv, value tarballv, value directoryv)
3279 CAMLparam3 (gv, tarballv, directoryv);
3282 guestfs_h *g = Guestfs_val (gv);
3284 caml_failwith ("tgz_in: used handle after closing it");
3286 const char *tarball = String_val (tarballv);
3287 const char *directory = String_val (directoryv);
3290 caml_enter_blocking_section ();
3291 r = guestfs_tgz_in (g, tarball, directory);
3292 caml_leave_blocking_section ();
3294 ocaml_guestfs_raise_error (g, "tgz_in");
3301 ocaml_guestfs_tgz_out (value gv, value directoryv, value tarballv)
3303 CAMLparam3 (gv, directoryv, tarballv);
3306 guestfs_h *g = Guestfs_val (gv);
3308 caml_failwith ("tgz_out: used handle after closing it");
3310 const char *directory = String_val (directoryv);
3311 const char *tarball = String_val (tarballv);
3314 caml_enter_blocking_section ();
3315 r = guestfs_tgz_out (g, directory, tarball);
3316 caml_leave_blocking_section ();
3318 ocaml_guestfs_raise_error (g, "tgz_out");
3325 ocaml_guestfs_mount_ro (value gv, value devicev, value mountpointv)
3327 CAMLparam3 (gv, devicev, mountpointv);
3330 guestfs_h *g = Guestfs_val (gv);
3332 caml_failwith ("mount_ro: used handle after closing it");
3334 const char *device = String_val (devicev);
3335 const char *mountpoint = String_val (mountpointv);
3338 caml_enter_blocking_section ();
3339 r = guestfs_mount_ro (g, device, mountpoint);
3340 caml_leave_blocking_section ();
3342 ocaml_guestfs_raise_error (g, "mount_ro");
3349 ocaml_guestfs_mount_options (value gv, value optionsv, value devicev, value mountpointv)
3351 CAMLparam4 (gv, optionsv, devicev, mountpointv);
3354 guestfs_h *g = Guestfs_val (gv);
3356 caml_failwith ("mount_options: used handle after closing it");
3358 const char *options = String_val (optionsv);
3359 const char *device = String_val (devicev);
3360 const char *mountpoint = String_val (mountpointv);
3363 caml_enter_blocking_section ();
3364 r = guestfs_mount_options (g, options, device, mountpoint);
3365 caml_leave_blocking_section ();
3367 ocaml_guestfs_raise_error (g, "mount_options");
3374 ocaml_guestfs_mount_vfs (value gv, value optionsv, value vfstypev, value devicev, value mountpointv)
3376 CAMLparam5 (gv, optionsv, vfstypev, devicev, mountpointv);
3379 guestfs_h *g = Guestfs_val (gv);
3381 caml_failwith ("mount_vfs: used handle after closing it");
3383 const char *options = String_val (optionsv);
3384 const char *vfstype = String_val (vfstypev);
3385 const char *device = String_val (devicev);
3386 const char *mountpoint = String_val (mountpointv);
3389 caml_enter_blocking_section ();
3390 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3391 caml_leave_blocking_section ();
3393 ocaml_guestfs_raise_error (g, "mount_vfs");
3400 ocaml_guestfs_debug (value gv, value subcmdv, value extraargsv)
3402 CAMLparam3 (gv, subcmdv, extraargsv);
3405 guestfs_h *g = Guestfs_val (gv);
3407 caml_failwith ("debug: used handle after closing it");
3409 const char *subcmd = String_val (subcmdv);
3410 char **extraargs = ocaml_guestfs_strings_val (g, extraargsv);
3413 caml_enter_blocking_section ();
3414 r = guestfs_debug (g, subcmd, extraargs);
3415 caml_leave_blocking_section ();
3416 ocaml_guestfs_free_strings (extraargs);
3418 ocaml_guestfs_raise_error (g, "debug");
3420 rv = caml_copy_string (r);
3426 ocaml_guestfs_lvremove (value gv, value devicev)
3428 CAMLparam2 (gv, devicev);
3431 guestfs_h *g = Guestfs_val (gv);
3433 caml_failwith ("lvremove: used handle after closing it");
3435 const char *device = String_val (devicev);
3438 caml_enter_blocking_section ();
3439 r = guestfs_lvremove (g, device);
3440 caml_leave_blocking_section ();
3442 ocaml_guestfs_raise_error (g, "lvremove");
3449 ocaml_guestfs_vgremove (value gv, value vgnamev)
3451 CAMLparam2 (gv, vgnamev);
3454 guestfs_h *g = Guestfs_val (gv);
3456 caml_failwith ("vgremove: used handle after closing it");
3458 const char *vgname = String_val (vgnamev);
3461 caml_enter_blocking_section ();
3462 r = guestfs_vgremove (g, vgname);
3463 caml_leave_blocking_section ();
3465 ocaml_guestfs_raise_error (g, "vgremove");
3472 ocaml_guestfs_pvremove (value gv, value devicev)
3474 CAMLparam2 (gv, devicev);
3477 guestfs_h *g = Guestfs_val (gv);
3479 caml_failwith ("pvremove: used handle after closing it");
3481 const char *device = String_val (devicev);
3484 caml_enter_blocking_section ();
3485 r = guestfs_pvremove (g, device);
3486 caml_leave_blocking_section ();
3488 ocaml_guestfs_raise_error (g, "pvremove");
3495 ocaml_guestfs_set_e2label (value gv, value devicev, value labelv)
3497 CAMLparam3 (gv, devicev, labelv);
3500 guestfs_h *g = Guestfs_val (gv);
3502 caml_failwith ("set_e2label: used handle after closing it");
3504 const char *device = String_val (devicev);
3505 const char *label = String_val (labelv);
3508 caml_enter_blocking_section ();
3509 r = guestfs_set_e2label (g, device, label);
3510 caml_leave_blocking_section ();
3512 ocaml_guestfs_raise_error (g, "set_e2label");
3519 ocaml_guestfs_get_e2label (value gv, value devicev)
3521 CAMLparam2 (gv, devicev);
3524 guestfs_h *g = Guestfs_val (gv);
3526 caml_failwith ("get_e2label: used handle after closing it");
3528 const char *device = String_val (devicev);
3531 caml_enter_blocking_section ();
3532 r = guestfs_get_e2label (g, device);
3533 caml_leave_blocking_section ();
3535 ocaml_guestfs_raise_error (g, "get_e2label");
3537 rv = caml_copy_string (r);
3543 ocaml_guestfs_set_e2uuid (value gv, value devicev, value uuidv)
3545 CAMLparam3 (gv, devicev, uuidv);
3548 guestfs_h *g = Guestfs_val (gv);
3550 caml_failwith ("set_e2uuid: used handle after closing it");
3552 const char *device = String_val (devicev);
3553 const char *uuid = String_val (uuidv);
3556 caml_enter_blocking_section ();
3557 r = guestfs_set_e2uuid (g, device, uuid);
3558 caml_leave_blocking_section ();
3560 ocaml_guestfs_raise_error (g, "set_e2uuid");
3567 ocaml_guestfs_get_e2uuid (value gv, value devicev)
3569 CAMLparam2 (gv, devicev);
3572 guestfs_h *g = Guestfs_val (gv);
3574 caml_failwith ("get_e2uuid: used handle after closing it");
3576 const char *device = String_val (devicev);
3579 caml_enter_blocking_section ();
3580 r = guestfs_get_e2uuid (g, device);
3581 caml_leave_blocking_section ();
3583 ocaml_guestfs_raise_error (g, "get_e2uuid");
3585 rv = caml_copy_string (r);
3591 ocaml_guestfs_fsck (value gv, value fstypev, value devicev)
3593 CAMLparam3 (gv, fstypev, devicev);
3596 guestfs_h *g = Guestfs_val (gv);
3598 caml_failwith ("fsck: used handle after closing it");
3600 const char *fstype = String_val (fstypev);
3601 const char *device = String_val (devicev);
3604 caml_enter_blocking_section ();
3605 r = guestfs_fsck (g, fstype, device);
3606 caml_leave_blocking_section ();
3608 ocaml_guestfs_raise_error (g, "fsck");
3615 ocaml_guestfs_zero (value gv, value devicev)
3617 CAMLparam2 (gv, devicev);
3620 guestfs_h *g = Guestfs_val (gv);
3622 caml_failwith ("zero: used handle after closing it");
3624 const char *device = String_val (devicev);
3627 caml_enter_blocking_section ();
3628 r = guestfs_zero (g, device);
3629 caml_leave_blocking_section ();
3631 ocaml_guestfs_raise_error (g, "zero");
3638 ocaml_guestfs_grub_install (value gv, value rootv, value devicev)
3640 CAMLparam3 (gv, rootv, devicev);
3643 guestfs_h *g = Guestfs_val (gv);
3645 caml_failwith ("grub_install: used handle after closing it");
3647 const char *root = String_val (rootv);
3648 const char *device = String_val (devicev);
3651 caml_enter_blocking_section ();
3652 r = guestfs_grub_install (g, root, device);
3653 caml_leave_blocking_section ();
3655 ocaml_guestfs_raise_error (g, "grub_install");
3662 ocaml_guestfs_cp (value gv, value srcv, value destv)
3664 CAMLparam3 (gv, srcv, destv);
3667 guestfs_h *g = Guestfs_val (gv);
3669 caml_failwith ("cp: used handle after closing it");
3671 const char *src = String_val (srcv);
3672 const char *dest = String_val (destv);
3675 caml_enter_blocking_section ();
3676 r = guestfs_cp (g, src, dest);
3677 caml_leave_blocking_section ();
3679 ocaml_guestfs_raise_error (g, "cp");
3686 ocaml_guestfs_cp_a (value gv, value srcv, value destv)
3688 CAMLparam3 (gv, srcv, destv);
3691 guestfs_h *g = Guestfs_val (gv);
3693 caml_failwith ("cp_a: used handle after closing it");
3695 const char *src = String_val (srcv);
3696 const char *dest = String_val (destv);
3699 caml_enter_blocking_section ();
3700 r = guestfs_cp_a (g, src, dest);
3701 caml_leave_blocking_section ();
3703 ocaml_guestfs_raise_error (g, "cp_a");
3710 ocaml_guestfs_mv (value gv, value srcv, value destv)
3712 CAMLparam3 (gv, srcv, destv);
3715 guestfs_h *g = Guestfs_val (gv);
3717 caml_failwith ("mv: used handle after closing it");
3719 const char *src = String_val (srcv);
3720 const char *dest = String_val (destv);
3723 caml_enter_blocking_section ();
3724 r = guestfs_mv (g, src, dest);
3725 caml_leave_blocking_section ();
3727 ocaml_guestfs_raise_error (g, "mv");
3734 ocaml_guestfs_drop_caches (value gv, value whattodropv)
3736 CAMLparam2 (gv, whattodropv);
3739 guestfs_h *g = Guestfs_val (gv);
3741 caml_failwith ("drop_caches: used handle after closing it");
3743 int whattodrop = Int_val (whattodropv);
3746 caml_enter_blocking_section ();
3747 r = guestfs_drop_caches (g, whattodrop);
3748 caml_leave_blocking_section ();
3750 ocaml_guestfs_raise_error (g, "drop_caches");
3757 ocaml_guestfs_dmesg (value gv)
3762 guestfs_h *g = Guestfs_val (gv);
3764 caml_failwith ("dmesg: used handle after closing it");
3768 caml_enter_blocking_section ();
3769 r = guestfs_dmesg (g);
3770 caml_leave_blocking_section ();
3772 ocaml_guestfs_raise_error (g, "dmesg");
3774 rv = caml_copy_string (r);
3780 ocaml_guestfs_ping_daemon (value gv)
3785 guestfs_h *g = Guestfs_val (gv);
3787 caml_failwith ("ping_daemon: used handle after closing it");
3791 caml_enter_blocking_section ();
3792 r = guestfs_ping_daemon (g);
3793 caml_leave_blocking_section ();
3795 ocaml_guestfs_raise_error (g, "ping_daemon");
3802 ocaml_guestfs_equal (value gv, value file1v, value file2v)
3804 CAMLparam3 (gv, file1v, file2v);
3807 guestfs_h *g = Guestfs_val (gv);
3809 caml_failwith ("equal: used handle after closing it");
3811 const char *file1 = String_val (file1v);
3812 const char *file2 = String_val (file2v);
3815 caml_enter_blocking_section ();
3816 r = guestfs_equal (g, file1, file2);
3817 caml_leave_blocking_section ();
3819 ocaml_guestfs_raise_error (g, "equal");
3826 ocaml_guestfs_strings (value gv, value pathv)
3828 CAMLparam2 (gv, pathv);
3831 guestfs_h *g = Guestfs_val (gv);
3833 caml_failwith ("strings: used handle after closing it");
3835 const char *path = String_val (pathv);
3839 caml_enter_blocking_section ();
3840 r = guestfs_strings (g, path);
3841 caml_leave_blocking_section ();
3843 ocaml_guestfs_raise_error (g, "strings");
3845 rv = caml_copy_string_array ((const char **) r);
3846 for (i = 0; r[i] != NULL; ++i) free (r[i]);
3852 ocaml_guestfs_strings_e (value gv, value encodingv, value pathv)
3854 CAMLparam3 (gv, encodingv, pathv);
3857 guestfs_h *g = Guestfs_val (gv);
3859 caml_failwith ("strings_e: used handle after closing it");
3861 const char *encoding = String_val (encodingv);
3862 const char *path = String_val (pathv);
3866 caml_enter_blocking_section ();
3867 r = guestfs_strings_e (g, encoding, path);
3868 caml_leave_blocking_section ();
3870 ocaml_guestfs_raise_error (g, "strings_e");
3872 rv = caml_copy_string_array ((const char **) r);
3873 for (i = 0; r[i] != NULL; ++i) free (r[i]);
3879 ocaml_guestfs_hexdump (value gv, value pathv)
3881 CAMLparam2 (gv, pathv);
3884 guestfs_h *g = Guestfs_val (gv);
3886 caml_failwith ("hexdump: used handle after closing it");
3888 const char *path = String_val (pathv);
3891 caml_enter_blocking_section ();
3892 r = guestfs_hexdump (g, path);
3893 caml_leave_blocking_section ();
3895 ocaml_guestfs_raise_error (g, "hexdump");
3897 rv = caml_copy_string (r);
3903 ocaml_guestfs_zerofree (value gv, value devicev)
3905 CAMLparam2 (gv, devicev);
3908 guestfs_h *g = Guestfs_val (gv);
3910 caml_failwith ("zerofree: used handle after closing it");
3912 const char *device = String_val (devicev);
3915 caml_enter_blocking_section ();
3916 r = guestfs_zerofree (g, device);
3917 caml_leave_blocking_section ();
3919 ocaml_guestfs_raise_error (g, "zerofree");
3926 ocaml_guestfs_pvresize (value gv, value devicev)
3928 CAMLparam2 (gv, devicev);
3931 guestfs_h *g = Guestfs_val (gv);
3933 caml_failwith ("pvresize: used handle after closing it");
3935 const char *device = String_val (devicev);
3938 caml_enter_blocking_section ();
3939 r = guestfs_pvresize (g, device);
3940 caml_leave_blocking_section ();
3942 ocaml_guestfs_raise_error (g, "pvresize");
3949 ocaml_guestfs_sfdisk_N (value gv, value devicev, value partnumv, value cylsv, value headsv, value sectorsv, value linev)
3951 CAMLparam5 (gv, devicev, partnumv, cylsv, headsv);
3952 CAMLxparam2 (sectorsv, linev);
3955 guestfs_h *g = Guestfs_val (gv);
3957 caml_failwith ("sfdisk_N: used handle after closing it");
3959 const char *device = String_val (devicev);
3960 int partnum = Int_val (partnumv);
3961 int cyls = Int_val (cylsv);
3962 int heads = Int_val (headsv);
3963 int sectors = Int_val (sectorsv);
3964 const char *line = String_val (linev);
3967 caml_enter_blocking_section ();
3968 r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
3969 caml_leave_blocking_section ();
3971 ocaml_guestfs_raise_error (g, "sfdisk_N");
3978 ocaml_guestfs_sfdisk_N_byte (value *argv, int argn)
3980 return ocaml_guestfs_sfdisk_N (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
3984 ocaml_guestfs_sfdisk_l (value gv, value devicev)
3986 CAMLparam2 (gv, devicev);
3989 guestfs_h *g = Guestfs_val (gv);
3991 caml_failwith ("sfdisk_l: used handle after closing it");
3993 const char *device = String_val (devicev);
3996 caml_enter_blocking_section ();
3997 r = guestfs_sfdisk_l (g, device);
3998 caml_leave_blocking_section ();
4000 ocaml_guestfs_raise_error (g, "sfdisk_l");
4002 rv = caml_copy_string (r);
4008 ocaml_guestfs_sfdisk_kernel_geometry (value gv, value devicev)
4010 CAMLparam2 (gv, devicev);
4013 guestfs_h *g = Guestfs_val (gv);
4015 caml_failwith ("sfdisk_kernel_geometry: used handle after closing it");
4017 const char *device = String_val (devicev);
4020 caml_enter_blocking_section ();
4021 r = guestfs_sfdisk_kernel_geometry (g, device);
4022 caml_leave_blocking_section ();
4024 ocaml_guestfs_raise_error (g, "sfdisk_kernel_geometry");
4026 rv = caml_copy_string (r);
4032 ocaml_guestfs_sfdisk_disk_geometry (value gv, value devicev)
4034 CAMLparam2 (gv, devicev);
4037 guestfs_h *g = Guestfs_val (gv);
4039 caml_failwith ("sfdisk_disk_geometry: used handle after closing it");
4041 const char *device = String_val (devicev);
4044 caml_enter_blocking_section ();
4045 r = guestfs_sfdisk_disk_geometry (g, device);
4046 caml_leave_blocking_section ();
4048 ocaml_guestfs_raise_error (g, "sfdisk_disk_geometry");
4050 rv = caml_copy_string (r);
4056 ocaml_guestfs_vg_activate_all (value gv, value activatev)
4058 CAMLparam2 (gv, activatev);
4061 guestfs_h *g = Guestfs_val (gv);
4063 caml_failwith ("vg_activate_all: used handle after closing it");
4065 int activate = Bool_val (activatev);
4068 caml_enter_blocking_section ();
4069 r = guestfs_vg_activate_all (g, activate);
4070 caml_leave_blocking_section ();
4072 ocaml_guestfs_raise_error (g, "vg_activate_all");
4079 ocaml_guestfs_vg_activate (value gv, value activatev, value volgroupsv)
4081 CAMLparam3 (gv, activatev, volgroupsv);
4084 guestfs_h *g = Guestfs_val (gv);
4086 caml_failwith ("vg_activate: used handle after closing it");
4088 int activate = Bool_val (activatev);
4089 char **volgroups = ocaml_guestfs_strings_val (g, volgroupsv);
4092 caml_enter_blocking_section ();
4093 r = guestfs_vg_activate (g, activate, volgroups);
4094 caml_leave_blocking_section ();
4095 ocaml_guestfs_free_strings (volgroups);
4097 ocaml_guestfs_raise_error (g, "vg_activate");
4104 ocaml_guestfs_lvresize (value gv, value devicev, value mbytesv)
4106 CAMLparam3 (gv, devicev, mbytesv);
4109 guestfs_h *g = Guestfs_val (gv);
4111 caml_failwith ("lvresize: used handle after closing it");
4113 const char *device = String_val (devicev);
4114 int mbytes = Int_val (mbytesv);
4117 caml_enter_blocking_section ();
4118 r = guestfs_lvresize (g, device, mbytes);
4119 caml_leave_blocking_section ();
4121 ocaml_guestfs_raise_error (g, "lvresize");
4128 ocaml_guestfs_resize2fs (value gv, value devicev)
4130 CAMLparam2 (gv, devicev);
4133 guestfs_h *g = Guestfs_val (gv);
4135 caml_failwith ("resize2fs: used handle after closing it");
4137 const char *device = String_val (devicev);
4140 caml_enter_blocking_section ();
4141 r = guestfs_resize2fs (g, device);
4142 caml_leave_blocking_section ();
4144 ocaml_guestfs_raise_error (g, "resize2fs");
4151 ocaml_guestfs_find (value gv, value directoryv)
4153 CAMLparam2 (gv, directoryv);
4156 guestfs_h *g = Guestfs_val (gv);
4158 caml_failwith ("find: used handle after closing it");
4160 const char *directory = String_val (directoryv);
4164 caml_enter_blocking_section ();
4165 r = guestfs_find (g, directory);
4166 caml_leave_blocking_section ();
4168 ocaml_guestfs_raise_error (g, "find");
4170 rv = caml_copy_string_array ((const char **) r);
4171 for (i = 0; r[i] != NULL; ++i) free (r[i]);
4177 ocaml_guestfs_e2fsck_f (value gv, value devicev)
4179 CAMLparam2 (gv, devicev);
4182 guestfs_h *g = Guestfs_val (gv);
4184 caml_failwith ("e2fsck_f: used handle after closing it");
4186 const char *device = String_val (devicev);
4189 caml_enter_blocking_section ();
4190 r = guestfs_e2fsck_f (g, device);
4191 caml_leave_blocking_section ();
4193 ocaml_guestfs_raise_error (g, "e2fsck_f");
4200 ocaml_guestfs_sleep (value gv, value secsv)
4202 CAMLparam2 (gv, secsv);
4205 guestfs_h *g = Guestfs_val (gv);
4207 caml_failwith ("sleep: used handle after closing it");
4209 int secs = Int_val (secsv);
4212 caml_enter_blocking_section ();
4213 r = guestfs_sleep (g, secs);
4214 caml_leave_blocking_section ();
4216 ocaml_guestfs_raise_error (g, "sleep");
4223 ocaml_guestfs_ntfs_3g_probe (value gv, value rwv, value devicev)
4225 CAMLparam3 (gv, rwv, devicev);
4228 guestfs_h *g = Guestfs_val (gv);
4230 caml_failwith ("ntfs_3g_probe: used handle after closing it");
4232 int rw = Bool_val (rwv);
4233 const char *device = String_val (devicev);
4236 caml_enter_blocking_section ();
4237 r = guestfs_ntfs_3g_probe (g, rw, device);
4238 caml_leave_blocking_section ();
4240 ocaml_guestfs_raise_error (g, "ntfs_3g_probe");
4247 ocaml_guestfs_sh (value gv, value commandv)
4249 CAMLparam2 (gv, commandv);
4252 guestfs_h *g = Guestfs_val (gv);
4254 caml_failwith ("sh: used handle after closing it");
4256 const char *command = String_val (commandv);
4259 caml_enter_blocking_section ();
4260 r = guestfs_sh (g, command);
4261 caml_leave_blocking_section ();
4263 ocaml_guestfs_raise_error (g, "sh");
4265 rv = caml_copy_string (r);
4271 ocaml_guestfs_sh_lines (value gv, value commandv)
4273 CAMLparam2 (gv, commandv);
4276 guestfs_h *g = Guestfs_val (gv);
4278 caml_failwith ("sh_lines: used handle after closing it");
4280 const char *command = String_val (commandv);
4284 caml_enter_blocking_section ();
4285 r = guestfs_sh_lines (g, command);
4286 caml_leave_blocking_section ();
4288 ocaml_guestfs_raise_error (g, "sh_lines");
4290 rv = caml_copy_string_array ((const char **) r);
4291 for (i = 0; r[i] != NULL; ++i) free (r[i]);
4297 ocaml_guestfs_glob_expand (value gv, value patternv)
4299 CAMLparam2 (gv, patternv);
4302 guestfs_h *g = Guestfs_val (gv);
4304 caml_failwith ("glob_expand: used handle after closing it");
4306 const char *pattern = String_val (patternv);
4310 caml_enter_blocking_section ();
4311 r = guestfs_glob_expand (g, pattern);
4312 caml_leave_blocking_section ();
4314 ocaml_guestfs_raise_error (g, "glob_expand");
4316 rv = caml_copy_string_array ((const char **) r);
4317 for (i = 0; r[i] != NULL; ++i) free (r[i]);
4323 ocaml_guestfs_scrub_device (value gv, value devicev)
4325 CAMLparam2 (gv, devicev);
4328 guestfs_h *g = Guestfs_val (gv);
4330 caml_failwith ("scrub_device: used handle after closing it");
4332 const char *device = String_val (devicev);
4335 caml_enter_blocking_section ();
4336 r = guestfs_scrub_device (g, device);
4337 caml_leave_blocking_section ();
4339 ocaml_guestfs_raise_error (g, "scrub_device");
4346 ocaml_guestfs_scrub_file (value gv, value filev)
4348 CAMLparam2 (gv, filev);
4351 guestfs_h *g = Guestfs_val (gv);
4353 caml_failwith ("scrub_file: used handle after closing it");
4355 const char *file = String_val (filev);
4358 caml_enter_blocking_section ();
4359 r = guestfs_scrub_file (g, file);
4360 caml_leave_blocking_section ();
4362 ocaml_guestfs_raise_error (g, "scrub_file");
4369 ocaml_guestfs_scrub_freespace (value gv, value dirv)
4371 CAMLparam2 (gv, dirv);
4374 guestfs_h *g = Guestfs_val (gv);
4376 caml_failwith ("scrub_freespace: used handle after closing it");
4378 const char *dir = String_val (dirv);
4381 caml_enter_blocking_section ();
4382 r = guestfs_scrub_freespace (g, dir);
4383 caml_leave_blocking_section ();
4385 ocaml_guestfs_raise_error (g, "scrub_freespace");
4392 ocaml_guestfs_mkdtemp (value gv, value templatev)
4394 CAMLparam2 (gv, templatev);
4397 guestfs_h *g = Guestfs_val (gv);
4399 caml_failwith ("mkdtemp: used handle after closing it");
4401 const char *template = String_val (templatev);
4404 caml_enter_blocking_section ();
4405 r = guestfs_mkdtemp (g, template);
4406 caml_leave_blocking_section ();
4408 ocaml_guestfs_raise_error (g, "mkdtemp");
4410 rv = caml_copy_string (r);
4416 ocaml_guestfs_wc_l (value gv, value pathv)
4418 CAMLparam2 (gv, pathv);
4421 guestfs_h *g = Guestfs_val (gv);
4423 caml_failwith ("wc_l: used handle after closing it");
4425 const char *path = String_val (pathv);
4428 caml_enter_blocking_section ();
4429 r = guestfs_wc_l (g, path);
4430 caml_leave_blocking_section ();
4432 ocaml_guestfs_raise_error (g, "wc_l");
4439 ocaml_guestfs_wc_w (value gv, value pathv)
4441 CAMLparam2 (gv, pathv);
4444 guestfs_h *g = Guestfs_val (gv);
4446 caml_failwith ("wc_w: used handle after closing it");
4448 const char *path = String_val (pathv);
4451 caml_enter_blocking_section ();
4452 r = guestfs_wc_w (g, path);
4453 caml_leave_blocking_section ();
4455 ocaml_guestfs_raise_error (g, "wc_w");
4462 ocaml_guestfs_wc_c (value gv, value pathv)
4464 CAMLparam2 (gv, pathv);
4467 guestfs_h *g = Guestfs_val (gv);
4469 caml_failwith ("wc_c: used handle after closing it");
4471 const char *path = String_val (pathv);
4474 caml_enter_blocking_section ();
4475 r = guestfs_wc_c (g, path);
4476 caml_leave_blocking_section ();
4478 ocaml_guestfs_raise_error (g, "wc_c");
4485 ocaml_guestfs_head (value gv, value pathv)
4487 CAMLparam2 (gv, pathv);
4490 guestfs_h *g = Guestfs_val (gv);
4492 caml_failwith ("head: used handle after closing it");
4494 const char *path = String_val (pathv);
4498 caml_enter_blocking_section ();
4499 r = guestfs_head (g, path);
4500 caml_leave_blocking_section ();
4502 ocaml_guestfs_raise_error (g, "head");
4504 rv = caml_copy_string_array ((const char **) r);
4505 for (i = 0; r[i] != NULL; ++i) free (r[i]);
4511 ocaml_guestfs_head_n (value gv, value nrlinesv, value pathv)
4513 CAMLparam3 (gv, nrlinesv, pathv);
4516 guestfs_h *g = Guestfs_val (gv);
4518 caml_failwith ("head_n: used handle after closing it");
4520 int nrlines = Int_val (nrlinesv);
4521 const char *path = String_val (pathv);
4525 caml_enter_blocking_section ();
4526 r = guestfs_head_n (g, nrlines, path);
4527 caml_leave_blocking_section ();
4529 ocaml_guestfs_raise_error (g, "head_n");
4531 rv = caml_copy_string_array ((const char **) r);
4532 for (i = 0; r[i] != NULL; ++i) free (r[i]);
4538 ocaml_guestfs_tail (value gv, value pathv)
4540 CAMLparam2 (gv, pathv);
4543 guestfs_h *g = Guestfs_val (gv);
4545 caml_failwith ("tail: used handle after closing it");
4547 const char *path = String_val (pathv);
4551 caml_enter_blocking_section ();
4552 r = guestfs_tail (g, path);
4553 caml_leave_blocking_section ();
4555 ocaml_guestfs_raise_error (g, "tail");
4557 rv = caml_copy_string_array ((const char **) r);
4558 for (i = 0; r[i] != NULL; ++i) free (r[i]);
4564 ocaml_guestfs_tail_n (value gv, value nrlinesv, value pathv)
4566 CAMLparam3 (gv, nrlinesv, pathv);
4569 guestfs_h *g = Guestfs_val (gv);
4571 caml_failwith ("tail_n: used handle after closing it");
4573 int nrlines = Int_val (nrlinesv);
4574 const char *path = String_val (pathv);
4578 caml_enter_blocking_section ();
4579 r = guestfs_tail_n (g, nrlines, path);
4580 caml_leave_blocking_section ();
4582 ocaml_guestfs_raise_error (g, "tail_n");
4584 rv = caml_copy_string_array ((const char **) r);
4585 for (i = 0; r[i] != NULL; ++i) free (r[i]);
4591 ocaml_guestfs_df (value gv)
4596 guestfs_h *g = Guestfs_val (gv);
4598 caml_failwith ("df: used handle after closing it");
4602 caml_enter_blocking_section ();
4604 caml_leave_blocking_section ();
4606 ocaml_guestfs_raise_error (g, "df");
4608 rv = caml_copy_string (r);
4614 ocaml_guestfs_df_h (value gv)
4619 guestfs_h *g = Guestfs_val (gv);
4621 caml_failwith ("df_h: used handle after closing it");
4625 caml_enter_blocking_section ();
4626 r = guestfs_df_h (g);
4627 caml_leave_blocking_section ();
4629 ocaml_guestfs_raise_error (g, "df_h");
4631 rv = caml_copy_string (r);
4637 ocaml_guestfs_du (value gv, value pathv)
4639 CAMLparam2 (gv, pathv);
4642 guestfs_h *g = Guestfs_val (gv);
4644 caml_failwith ("du: used handle after closing it");
4646 const char *path = String_val (pathv);
4649 caml_enter_blocking_section ();
4650 r = guestfs_du (g, path);
4651 caml_leave_blocking_section ();
4653 ocaml_guestfs_raise_error (g, "du");
4655 rv = caml_copy_int64 (r);
4660 ocaml_guestfs_initrd_list (value gv, value pathv)
4662 CAMLparam2 (gv, pathv);
4665 guestfs_h *g = Guestfs_val (gv);
4667 caml_failwith ("initrd_list: used handle after closing it");
4669 const char *path = String_val (pathv);
4673 caml_enter_blocking_section ();
4674 r = guestfs_initrd_list (g, path);
4675 caml_leave_blocking_section ();
4677 ocaml_guestfs_raise_error (g, "initrd_list");
4679 rv = caml_copy_string_array ((const char **) r);
4680 for (i = 0; r[i] != NULL; ++i) free (r[i]);
4686 ocaml_guestfs_mount_loop (value gv, value filev, value mountpointv)
4688 CAMLparam3 (gv, filev, mountpointv);
4691 guestfs_h *g = Guestfs_val (gv);
4693 caml_failwith ("mount_loop: used handle after closing it");
4695 const char *file = String_val (filev);
4696 const char *mountpoint = String_val (mountpointv);
4699 caml_enter_blocking_section ();
4700 r = guestfs_mount_loop (g, file, mountpoint);
4701 caml_leave_blocking_section ();
4703 ocaml_guestfs_raise_error (g, "mount_loop");
4710 ocaml_guestfs_mkswap (value gv, value devicev)
4712 CAMLparam2 (gv, devicev);
4715 guestfs_h *g = Guestfs_val (gv);
4717 caml_failwith ("mkswap: used handle after closing it");
4719 const char *device = String_val (devicev);
4722 caml_enter_blocking_section ();
4723 r = guestfs_mkswap (g, device);
4724 caml_leave_blocking_section ();
4726 ocaml_guestfs_raise_error (g, "mkswap");
4733 ocaml_guestfs_mkswap_L (value gv, value labelv, value devicev)
4735 CAMLparam3 (gv, labelv, devicev);
4738 guestfs_h *g = Guestfs_val (gv);
4740 caml_failwith ("mkswap_L: used handle after closing it");
4742 const char *label = String_val (labelv);
4743 const char *device = String_val (devicev);
4746 caml_enter_blocking_section ();
4747 r = guestfs_mkswap_L (g, label, device);
4748 caml_leave_blocking_section ();
4750 ocaml_guestfs_raise_error (g, "mkswap_L");
4757 ocaml_guestfs_mkswap_U (value gv, value uuidv, value devicev)
4759 CAMLparam3 (gv, uuidv, devicev);
4762 guestfs_h *g = Guestfs_val (gv);
4764 caml_failwith ("mkswap_U: used handle after closing it");
4766 const char *uuid = String_val (uuidv);
4767 const char *device = String_val (devicev);
4770 caml_enter_blocking_section ();
4771 r = guestfs_mkswap_U (g, uuid, device);
4772 caml_leave_blocking_section ();
4774 ocaml_guestfs_raise_error (g, "mkswap_U");