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_config (value gv, value qemuparamv, value qemuvaluev)
1099 CAMLparam3 (gv, qemuparamv, qemuvaluev);
1102 guestfs_h *g = Guestfs_val (gv);
1104 caml_failwith ("config: used handle after closing it");
1106 const char *qemuparam = String_val (qemuparamv);
1107 const char *qemuvalue =
1108 qemuvaluev != Val_int (0) ? String_val (Field (qemuvaluev, 0)) : NULL;
1111 caml_enter_blocking_section ();
1112 r = guestfs_config (g, qemuparam, qemuvalue);
1113 caml_leave_blocking_section ();
1115 ocaml_guestfs_raise_error (g, "config");
1122 ocaml_guestfs_set_qemu (value gv, value qemuv)
1124 CAMLparam2 (gv, qemuv);
1127 guestfs_h *g = Guestfs_val (gv);
1129 caml_failwith ("set_qemu: used handle after closing it");
1131 const char *qemu = String_val (qemuv);
1134 caml_enter_blocking_section ();
1135 r = guestfs_set_qemu (g, qemu);
1136 caml_leave_blocking_section ();
1138 ocaml_guestfs_raise_error (g, "set_qemu");
1145 ocaml_guestfs_get_qemu (value gv)
1150 guestfs_h *g = Guestfs_val (gv);
1152 caml_failwith ("get_qemu: used handle after closing it");
1156 caml_enter_blocking_section ();
1157 r = guestfs_get_qemu (g);
1158 caml_leave_blocking_section ();
1160 ocaml_guestfs_raise_error (g, "get_qemu");
1162 rv = caml_copy_string (r);
1167 ocaml_guestfs_set_path (value gv, value pathv)
1169 CAMLparam2 (gv, pathv);
1172 guestfs_h *g = Guestfs_val (gv);
1174 caml_failwith ("set_path: used handle after closing it");
1176 const char *path = String_val (pathv);
1179 caml_enter_blocking_section ();
1180 r = guestfs_set_path (g, path);
1181 caml_leave_blocking_section ();
1183 ocaml_guestfs_raise_error (g, "set_path");
1190 ocaml_guestfs_get_path (value gv)
1195 guestfs_h *g = Guestfs_val (gv);
1197 caml_failwith ("get_path: used handle after closing it");
1201 caml_enter_blocking_section ();
1202 r = guestfs_get_path (g);
1203 caml_leave_blocking_section ();
1205 ocaml_guestfs_raise_error (g, "get_path");
1207 rv = caml_copy_string (r);
1212 ocaml_guestfs_set_append (value gv, value appendv)
1214 CAMLparam2 (gv, appendv);
1217 guestfs_h *g = Guestfs_val (gv);
1219 caml_failwith ("set_append: used handle after closing it");
1221 const char *append = String_val (appendv);
1224 caml_enter_blocking_section ();
1225 r = guestfs_set_append (g, append);
1226 caml_leave_blocking_section ();
1228 ocaml_guestfs_raise_error (g, "set_append");
1235 ocaml_guestfs_get_append (value gv)
1240 guestfs_h *g = Guestfs_val (gv);
1242 caml_failwith ("get_append: used handle after closing it");
1246 caml_enter_blocking_section ();
1247 r = guestfs_get_append (g);
1248 caml_leave_blocking_section ();
1250 ocaml_guestfs_raise_error (g, "get_append");
1252 rv = caml_copy_string (r);
1257 ocaml_guestfs_set_autosync (value gv, value autosyncv)
1259 CAMLparam2 (gv, autosyncv);
1262 guestfs_h *g = Guestfs_val (gv);
1264 caml_failwith ("set_autosync: used handle after closing it");
1266 int autosync = Bool_val (autosyncv);
1269 caml_enter_blocking_section ();
1270 r = guestfs_set_autosync (g, autosync);
1271 caml_leave_blocking_section ();
1273 ocaml_guestfs_raise_error (g, "set_autosync");
1280 ocaml_guestfs_get_autosync (value gv)
1285 guestfs_h *g = Guestfs_val (gv);
1287 caml_failwith ("get_autosync: used handle after closing it");
1291 caml_enter_blocking_section ();
1292 r = guestfs_get_autosync (g);
1293 caml_leave_blocking_section ();
1295 ocaml_guestfs_raise_error (g, "get_autosync");
1302 ocaml_guestfs_set_verbose (value gv, value verbosev)
1304 CAMLparam2 (gv, verbosev);
1307 guestfs_h *g = Guestfs_val (gv);
1309 caml_failwith ("set_verbose: used handle after closing it");
1311 int verbose = Bool_val (verbosev);
1314 caml_enter_blocking_section ();
1315 r = guestfs_set_verbose (g, verbose);
1316 caml_leave_blocking_section ();
1318 ocaml_guestfs_raise_error (g, "set_verbose");
1325 ocaml_guestfs_get_verbose (value gv)
1330 guestfs_h *g = Guestfs_val (gv);
1332 caml_failwith ("get_verbose: used handle after closing it");
1336 caml_enter_blocking_section ();
1337 r = guestfs_get_verbose (g);
1338 caml_leave_blocking_section ();
1340 ocaml_guestfs_raise_error (g, "get_verbose");
1347 ocaml_guestfs_is_ready (value gv)
1352 guestfs_h *g = Guestfs_val (gv);
1354 caml_failwith ("is_ready: used handle after closing it");
1358 caml_enter_blocking_section ();
1359 r = guestfs_is_ready (g);
1360 caml_leave_blocking_section ();
1362 ocaml_guestfs_raise_error (g, "is_ready");
1369 ocaml_guestfs_is_config (value gv)
1374 guestfs_h *g = Guestfs_val (gv);
1376 caml_failwith ("is_config: used handle after closing it");
1380 caml_enter_blocking_section ();
1381 r = guestfs_is_config (g);
1382 caml_leave_blocking_section ();
1384 ocaml_guestfs_raise_error (g, "is_config");
1391 ocaml_guestfs_is_launching (value gv)
1396 guestfs_h *g = Guestfs_val (gv);
1398 caml_failwith ("is_launching: used handle after closing it");
1402 caml_enter_blocking_section ();
1403 r = guestfs_is_launching (g);
1404 caml_leave_blocking_section ();
1406 ocaml_guestfs_raise_error (g, "is_launching");
1413 ocaml_guestfs_is_busy (value gv)
1418 guestfs_h *g = Guestfs_val (gv);
1420 caml_failwith ("is_busy: used handle after closing it");
1424 caml_enter_blocking_section ();
1425 r = guestfs_is_busy (g);
1426 caml_leave_blocking_section ();
1428 ocaml_guestfs_raise_error (g, "is_busy");
1435 ocaml_guestfs_get_state (value gv)
1440 guestfs_h *g = Guestfs_val (gv);
1442 caml_failwith ("get_state: used handle after closing it");
1446 caml_enter_blocking_section ();
1447 r = guestfs_get_state (g);
1448 caml_leave_blocking_section ();
1450 ocaml_guestfs_raise_error (g, "get_state");
1457 ocaml_guestfs_set_busy (value gv)
1462 guestfs_h *g = Guestfs_val (gv);
1464 caml_failwith ("set_busy: used handle after closing it");
1468 caml_enter_blocking_section ();
1469 r = guestfs_set_busy (g);
1470 caml_leave_blocking_section ();
1472 ocaml_guestfs_raise_error (g, "set_busy");
1479 ocaml_guestfs_set_ready (value gv)
1484 guestfs_h *g = Guestfs_val (gv);
1486 caml_failwith ("set_ready: used handle after closing it");
1490 caml_enter_blocking_section ();
1491 r = guestfs_set_ready (g);
1492 caml_leave_blocking_section ();
1494 ocaml_guestfs_raise_error (g, "set_ready");
1501 ocaml_guestfs_end_busy (value gv)
1506 guestfs_h *g = Guestfs_val (gv);
1508 caml_failwith ("end_busy: used handle after closing it");
1512 caml_enter_blocking_section ();
1513 r = guestfs_end_busy (g);
1514 caml_leave_blocking_section ();
1516 ocaml_guestfs_raise_error (g, "end_busy");
1523 ocaml_guestfs_mount (value gv, value devicev, value mountpointv)
1525 CAMLparam3 (gv, devicev, mountpointv);
1528 guestfs_h *g = Guestfs_val (gv);
1530 caml_failwith ("mount: used handle after closing it");
1532 const char *device = String_val (devicev);
1533 const char *mountpoint = String_val (mountpointv);
1536 caml_enter_blocking_section ();
1537 r = guestfs_mount (g, device, mountpoint);
1538 caml_leave_blocking_section ();
1540 ocaml_guestfs_raise_error (g, "mount");
1547 ocaml_guestfs_sync (value gv)
1552 guestfs_h *g = Guestfs_val (gv);
1554 caml_failwith ("sync: used handle after closing it");
1558 caml_enter_blocking_section ();
1559 r = guestfs_sync (g);
1560 caml_leave_blocking_section ();
1562 ocaml_guestfs_raise_error (g, "sync");
1569 ocaml_guestfs_touch (value gv, value pathv)
1571 CAMLparam2 (gv, pathv);
1574 guestfs_h *g = Guestfs_val (gv);
1576 caml_failwith ("touch: used handle after closing it");
1578 const char *path = String_val (pathv);
1581 caml_enter_blocking_section ();
1582 r = guestfs_touch (g, path);
1583 caml_leave_blocking_section ();
1585 ocaml_guestfs_raise_error (g, "touch");
1592 ocaml_guestfs_cat (value gv, value pathv)
1594 CAMLparam2 (gv, pathv);
1597 guestfs_h *g = Guestfs_val (gv);
1599 caml_failwith ("cat: used handle after closing it");
1601 const char *path = String_val (pathv);
1604 caml_enter_blocking_section ();
1605 r = guestfs_cat (g, path);
1606 caml_leave_blocking_section ();
1608 ocaml_guestfs_raise_error (g, "cat");
1610 rv = caml_copy_string (r);
1616 ocaml_guestfs_ll (value gv, value directoryv)
1618 CAMLparam2 (gv, directoryv);
1621 guestfs_h *g = Guestfs_val (gv);
1623 caml_failwith ("ll: used handle after closing it");
1625 const char *directory = String_val (directoryv);
1628 caml_enter_blocking_section ();
1629 r = guestfs_ll (g, directory);
1630 caml_leave_blocking_section ();
1632 ocaml_guestfs_raise_error (g, "ll");
1634 rv = caml_copy_string (r);
1640 ocaml_guestfs_ls (value gv, value directoryv)
1642 CAMLparam2 (gv, directoryv);
1645 guestfs_h *g = Guestfs_val (gv);
1647 caml_failwith ("ls: used handle after closing it");
1649 const char *directory = String_val (directoryv);
1653 caml_enter_blocking_section ();
1654 r = guestfs_ls (g, directory);
1655 caml_leave_blocking_section ();
1657 ocaml_guestfs_raise_error (g, "ls");
1659 rv = caml_copy_string_array ((const char **) r);
1660 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1666 ocaml_guestfs_list_devices (value gv)
1671 guestfs_h *g = Guestfs_val (gv);
1673 caml_failwith ("list_devices: used handle after closing it");
1678 caml_enter_blocking_section ();
1679 r = guestfs_list_devices (g);
1680 caml_leave_blocking_section ();
1682 ocaml_guestfs_raise_error (g, "list_devices");
1684 rv = caml_copy_string_array ((const char **) r);
1685 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1691 ocaml_guestfs_list_partitions (value gv)
1696 guestfs_h *g = Guestfs_val (gv);
1698 caml_failwith ("list_partitions: used handle after closing it");
1703 caml_enter_blocking_section ();
1704 r = guestfs_list_partitions (g);
1705 caml_leave_blocking_section ();
1707 ocaml_guestfs_raise_error (g, "list_partitions");
1709 rv = caml_copy_string_array ((const char **) r);
1710 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1716 ocaml_guestfs_pvs (value gv)
1721 guestfs_h *g = Guestfs_val (gv);
1723 caml_failwith ("pvs: used handle after closing it");
1728 caml_enter_blocking_section ();
1729 r = guestfs_pvs (g);
1730 caml_leave_blocking_section ();
1732 ocaml_guestfs_raise_error (g, "pvs");
1734 rv = caml_copy_string_array ((const char **) r);
1735 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1741 ocaml_guestfs_vgs (value gv)
1746 guestfs_h *g = Guestfs_val (gv);
1748 caml_failwith ("vgs: used handle after closing it");
1753 caml_enter_blocking_section ();
1754 r = guestfs_vgs (g);
1755 caml_leave_blocking_section ();
1757 ocaml_guestfs_raise_error (g, "vgs");
1759 rv = caml_copy_string_array ((const char **) r);
1760 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1766 ocaml_guestfs_lvs (value gv)
1771 guestfs_h *g = Guestfs_val (gv);
1773 caml_failwith ("lvs: used handle after closing it");
1778 caml_enter_blocking_section ();
1779 r = guestfs_lvs (g);
1780 caml_leave_blocking_section ();
1782 ocaml_guestfs_raise_error (g, "lvs");
1784 rv = caml_copy_string_array ((const char **) r);
1785 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1791 ocaml_guestfs_pvs_full (value gv)
1796 guestfs_h *g = Guestfs_val (gv);
1798 caml_failwith ("pvs_full: used handle after closing it");
1800 struct guestfs_lvm_pv_list *r;
1802 caml_enter_blocking_section ();
1803 r = guestfs_pvs_full (g);
1804 caml_leave_blocking_section ();
1806 ocaml_guestfs_raise_error (g, "pvs_full");
1808 rv = copy_lvm_pv_list (r);
1809 guestfs_free_lvm_pv_list (r);
1814 ocaml_guestfs_vgs_full (value gv)
1819 guestfs_h *g = Guestfs_val (gv);
1821 caml_failwith ("vgs_full: used handle after closing it");
1823 struct guestfs_lvm_vg_list *r;
1825 caml_enter_blocking_section ();
1826 r = guestfs_vgs_full (g);
1827 caml_leave_blocking_section ();
1829 ocaml_guestfs_raise_error (g, "vgs_full");
1831 rv = copy_lvm_vg_list (r);
1832 guestfs_free_lvm_vg_list (r);
1837 ocaml_guestfs_lvs_full (value gv)
1842 guestfs_h *g = Guestfs_val (gv);
1844 caml_failwith ("lvs_full: used handle after closing it");
1846 struct guestfs_lvm_lv_list *r;
1848 caml_enter_blocking_section ();
1849 r = guestfs_lvs_full (g);
1850 caml_leave_blocking_section ();
1852 ocaml_guestfs_raise_error (g, "lvs_full");
1854 rv = copy_lvm_lv_list (r);
1855 guestfs_free_lvm_lv_list (r);
1860 ocaml_guestfs_read_lines (value gv, value pathv)
1862 CAMLparam2 (gv, pathv);
1865 guestfs_h *g = Guestfs_val (gv);
1867 caml_failwith ("read_lines: used handle after closing it");
1869 const char *path = String_val (pathv);
1873 caml_enter_blocking_section ();
1874 r = guestfs_read_lines (g, path);
1875 caml_leave_blocking_section ();
1877 ocaml_guestfs_raise_error (g, "read_lines");
1879 rv = caml_copy_string_array ((const char **) r);
1880 for (i = 0; r[i] != NULL; ++i) free (r[i]);
1886 ocaml_guestfs_aug_init (value gv, value rootv, value flagsv)
1888 CAMLparam3 (gv, rootv, flagsv);
1891 guestfs_h *g = Guestfs_val (gv);
1893 caml_failwith ("aug_init: used handle after closing it");
1895 const char *root = String_val (rootv);
1896 int flags = Int_val (flagsv);
1899 caml_enter_blocking_section ();
1900 r = guestfs_aug_init (g, root, flags);
1901 caml_leave_blocking_section ();
1903 ocaml_guestfs_raise_error (g, "aug_init");
1910 ocaml_guestfs_aug_close (value gv)
1915 guestfs_h *g = Guestfs_val (gv);
1917 caml_failwith ("aug_close: used handle after closing it");
1921 caml_enter_blocking_section ();
1922 r = guestfs_aug_close (g);
1923 caml_leave_blocking_section ();
1925 ocaml_guestfs_raise_error (g, "aug_close");
1932 ocaml_guestfs_aug_defvar (value gv, value namev, value exprv)
1934 CAMLparam3 (gv, namev, exprv);
1937 guestfs_h *g = Guestfs_val (gv);
1939 caml_failwith ("aug_defvar: used handle after closing it");
1941 const char *name = String_val (namev);
1943 exprv != Val_int (0) ? String_val (Field (exprv, 0)) : NULL;
1946 caml_enter_blocking_section ();
1947 r = guestfs_aug_defvar (g, name, expr);
1948 caml_leave_blocking_section ();
1950 ocaml_guestfs_raise_error (g, "aug_defvar");
1957 ocaml_guestfs_aug_defnode (value gv, value namev, value exprv, value valv)
1959 CAMLparam4 (gv, namev, exprv, valv);
1962 guestfs_h *g = Guestfs_val (gv);
1964 caml_failwith ("aug_defnode: used handle after closing it");
1966 const char *name = String_val (namev);
1967 const char *expr = String_val (exprv);
1968 const char *val = String_val (valv);
1969 struct guestfs_int_bool *r;
1971 caml_enter_blocking_section ();
1972 r = guestfs_aug_defnode (g, name, expr, val);
1973 caml_leave_blocking_section ();
1975 ocaml_guestfs_raise_error (g, "aug_defnode");
1977 rv = caml_alloc (2, 0);
1978 Store_field (rv, 0, Val_int (r->i));
1979 Store_field (rv, 1, Val_bool (r->b));
1980 guestfs_free_int_bool (r);
1985 ocaml_guestfs_aug_get (value gv, value pathv)
1987 CAMLparam2 (gv, pathv);
1990 guestfs_h *g = Guestfs_val (gv);
1992 caml_failwith ("aug_get: used handle after closing it");
1994 const char *path = String_val (pathv);
1997 caml_enter_blocking_section ();
1998 r = guestfs_aug_get (g, path);
1999 caml_leave_blocking_section ();
2001 ocaml_guestfs_raise_error (g, "aug_get");
2003 rv = caml_copy_string (r);
2009 ocaml_guestfs_aug_set (value gv, value pathv, value valv)
2011 CAMLparam3 (gv, pathv, valv);
2014 guestfs_h *g = Guestfs_val (gv);
2016 caml_failwith ("aug_set: used handle after closing it");
2018 const char *path = String_val (pathv);
2019 const char *val = String_val (valv);
2022 caml_enter_blocking_section ();
2023 r = guestfs_aug_set (g, path, val);
2024 caml_leave_blocking_section ();
2026 ocaml_guestfs_raise_error (g, "aug_set");
2033 ocaml_guestfs_aug_insert (value gv, value pathv, value labelv, value beforev)
2035 CAMLparam4 (gv, pathv, labelv, beforev);
2038 guestfs_h *g = Guestfs_val (gv);
2040 caml_failwith ("aug_insert: used handle after closing it");
2042 const char *path = String_val (pathv);
2043 const char *label = String_val (labelv);
2044 int before = Bool_val (beforev);
2047 caml_enter_blocking_section ();
2048 r = guestfs_aug_insert (g, path, label, before);
2049 caml_leave_blocking_section ();
2051 ocaml_guestfs_raise_error (g, "aug_insert");
2058 ocaml_guestfs_aug_rm (value gv, value pathv)
2060 CAMLparam2 (gv, pathv);
2063 guestfs_h *g = Guestfs_val (gv);
2065 caml_failwith ("aug_rm: used handle after closing it");
2067 const char *path = String_val (pathv);
2070 caml_enter_blocking_section ();
2071 r = guestfs_aug_rm (g, path);
2072 caml_leave_blocking_section ();
2074 ocaml_guestfs_raise_error (g, "aug_rm");
2081 ocaml_guestfs_aug_mv (value gv, value srcv, value destv)
2083 CAMLparam3 (gv, srcv, destv);
2086 guestfs_h *g = Guestfs_val (gv);
2088 caml_failwith ("aug_mv: used handle after closing it");
2090 const char *src = String_val (srcv);
2091 const char *dest = String_val (destv);
2094 caml_enter_blocking_section ();
2095 r = guestfs_aug_mv (g, src, dest);
2096 caml_leave_blocking_section ();
2098 ocaml_guestfs_raise_error (g, "aug_mv");
2105 ocaml_guestfs_aug_match (value gv, value pathv)
2107 CAMLparam2 (gv, pathv);
2110 guestfs_h *g = Guestfs_val (gv);
2112 caml_failwith ("aug_match: used handle after closing it");
2114 const char *path = String_val (pathv);
2118 caml_enter_blocking_section ();
2119 r = guestfs_aug_match (g, path);
2120 caml_leave_blocking_section ();
2122 ocaml_guestfs_raise_error (g, "aug_match");
2124 rv = caml_copy_string_array ((const char **) r);
2125 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2131 ocaml_guestfs_aug_save (value gv)
2136 guestfs_h *g = Guestfs_val (gv);
2138 caml_failwith ("aug_save: used handle after closing it");
2142 caml_enter_blocking_section ();
2143 r = guestfs_aug_save (g);
2144 caml_leave_blocking_section ();
2146 ocaml_guestfs_raise_error (g, "aug_save");
2153 ocaml_guestfs_aug_load (value gv)
2158 guestfs_h *g = Guestfs_val (gv);
2160 caml_failwith ("aug_load: used handle after closing it");
2164 caml_enter_blocking_section ();
2165 r = guestfs_aug_load (g);
2166 caml_leave_blocking_section ();
2168 ocaml_guestfs_raise_error (g, "aug_load");
2175 ocaml_guestfs_aug_ls (value gv, value pathv)
2177 CAMLparam2 (gv, pathv);
2180 guestfs_h *g = Guestfs_val (gv);
2182 caml_failwith ("aug_ls: used handle after closing it");
2184 const char *path = String_val (pathv);
2188 caml_enter_blocking_section ();
2189 r = guestfs_aug_ls (g, path);
2190 caml_leave_blocking_section ();
2192 ocaml_guestfs_raise_error (g, "aug_ls");
2194 rv = caml_copy_string_array ((const char **) r);
2195 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2201 ocaml_guestfs_rm (value gv, value pathv)
2203 CAMLparam2 (gv, pathv);
2206 guestfs_h *g = Guestfs_val (gv);
2208 caml_failwith ("rm: used handle after closing it");
2210 const char *path = String_val (pathv);
2213 caml_enter_blocking_section ();
2214 r = guestfs_rm (g, path);
2215 caml_leave_blocking_section ();
2217 ocaml_guestfs_raise_error (g, "rm");
2224 ocaml_guestfs_rmdir (value gv, value pathv)
2226 CAMLparam2 (gv, pathv);
2229 guestfs_h *g = Guestfs_val (gv);
2231 caml_failwith ("rmdir: used handle after closing it");
2233 const char *path = String_val (pathv);
2236 caml_enter_blocking_section ();
2237 r = guestfs_rmdir (g, path);
2238 caml_leave_blocking_section ();
2240 ocaml_guestfs_raise_error (g, "rmdir");
2247 ocaml_guestfs_rm_rf (value gv, value pathv)
2249 CAMLparam2 (gv, pathv);
2252 guestfs_h *g = Guestfs_val (gv);
2254 caml_failwith ("rm_rf: used handle after closing it");
2256 const char *path = String_val (pathv);
2259 caml_enter_blocking_section ();
2260 r = guestfs_rm_rf (g, path);
2261 caml_leave_blocking_section ();
2263 ocaml_guestfs_raise_error (g, "rm_rf");
2270 ocaml_guestfs_mkdir (value gv, value pathv)
2272 CAMLparam2 (gv, pathv);
2275 guestfs_h *g = Guestfs_val (gv);
2277 caml_failwith ("mkdir: used handle after closing it");
2279 const char *path = String_val (pathv);
2282 caml_enter_blocking_section ();
2283 r = guestfs_mkdir (g, path);
2284 caml_leave_blocking_section ();
2286 ocaml_guestfs_raise_error (g, "mkdir");
2293 ocaml_guestfs_mkdir_p (value gv, value pathv)
2295 CAMLparam2 (gv, pathv);
2298 guestfs_h *g = Guestfs_val (gv);
2300 caml_failwith ("mkdir_p: used handle after closing it");
2302 const char *path = String_val (pathv);
2305 caml_enter_blocking_section ();
2306 r = guestfs_mkdir_p (g, path);
2307 caml_leave_blocking_section ();
2309 ocaml_guestfs_raise_error (g, "mkdir_p");
2316 ocaml_guestfs_chmod (value gv, value modev, value pathv)
2318 CAMLparam3 (gv, modev, pathv);
2321 guestfs_h *g = Guestfs_val (gv);
2323 caml_failwith ("chmod: used handle after closing it");
2325 int mode = Int_val (modev);
2326 const char *path = String_val (pathv);
2329 caml_enter_blocking_section ();
2330 r = guestfs_chmod (g, mode, path);
2331 caml_leave_blocking_section ();
2333 ocaml_guestfs_raise_error (g, "chmod");
2340 ocaml_guestfs_chown (value gv, value ownerv, value groupv, value pathv)
2342 CAMLparam4 (gv, ownerv, groupv, pathv);
2345 guestfs_h *g = Guestfs_val (gv);
2347 caml_failwith ("chown: used handle after closing it");
2349 int owner = Int_val (ownerv);
2350 int group = Int_val (groupv);
2351 const char *path = String_val (pathv);
2354 caml_enter_blocking_section ();
2355 r = guestfs_chown (g, owner, group, path);
2356 caml_leave_blocking_section ();
2358 ocaml_guestfs_raise_error (g, "chown");
2365 ocaml_guestfs_exists (value gv, value pathv)
2367 CAMLparam2 (gv, pathv);
2370 guestfs_h *g = Guestfs_val (gv);
2372 caml_failwith ("exists: used handle after closing it");
2374 const char *path = String_val (pathv);
2377 caml_enter_blocking_section ();
2378 r = guestfs_exists (g, path);
2379 caml_leave_blocking_section ();
2381 ocaml_guestfs_raise_error (g, "exists");
2388 ocaml_guestfs_is_file (value gv, value pathv)
2390 CAMLparam2 (gv, pathv);
2393 guestfs_h *g = Guestfs_val (gv);
2395 caml_failwith ("is_file: used handle after closing it");
2397 const char *path = String_val (pathv);
2400 caml_enter_blocking_section ();
2401 r = guestfs_is_file (g, path);
2402 caml_leave_blocking_section ();
2404 ocaml_guestfs_raise_error (g, "is_file");
2411 ocaml_guestfs_is_dir (value gv, value pathv)
2413 CAMLparam2 (gv, pathv);
2416 guestfs_h *g = Guestfs_val (gv);
2418 caml_failwith ("is_dir: used handle after closing it");
2420 const char *path = String_val (pathv);
2423 caml_enter_blocking_section ();
2424 r = guestfs_is_dir (g, path);
2425 caml_leave_blocking_section ();
2427 ocaml_guestfs_raise_error (g, "is_dir");
2434 ocaml_guestfs_pvcreate (value gv, value devicev)
2436 CAMLparam2 (gv, devicev);
2439 guestfs_h *g = Guestfs_val (gv);
2441 caml_failwith ("pvcreate: used handle after closing it");
2443 const char *device = String_val (devicev);
2446 caml_enter_blocking_section ();
2447 r = guestfs_pvcreate (g, device);
2448 caml_leave_blocking_section ();
2450 ocaml_guestfs_raise_error (g, "pvcreate");
2457 ocaml_guestfs_vgcreate (value gv, value volgroupv, value physvolsv)
2459 CAMLparam3 (gv, volgroupv, physvolsv);
2462 guestfs_h *g = Guestfs_val (gv);
2464 caml_failwith ("vgcreate: used handle after closing it");
2466 const char *volgroup = String_val (volgroupv);
2467 char **physvols = ocaml_guestfs_strings_val (g, physvolsv);
2470 caml_enter_blocking_section ();
2471 r = guestfs_vgcreate (g, volgroup, physvols);
2472 caml_leave_blocking_section ();
2473 ocaml_guestfs_free_strings (physvols);
2475 ocaml_guestfs_raise_error (g, "vgcreate");
2482 ocaml_guestfs_lvcreate (value gv, value logvolv, value volgroupv, value mbytesv)
2484 CAMLparam4 (gv, logvolv, volgroupv, mbytesv);
2487 guestfs_h *g = Guestfs_val (gv);
2489 caml_failwith ("lvcreate: used handle after closing it");
2491 const char *logvol = String_val (logvolv);
2492 const char *volgroup = String_val (volgroupv);
2493 int mbytes = Int_val (mbytesv);
2496 caml_enter_blocking_section ();
2497 r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2498 caml_leave_blocking_section ();
2500 ocaml_guestfs_raise_error (g, "lvcreate");
2507 ocaml_guestfs_mkfs (value gv, value fstypev, value devicev)
2509 CAMLparam3 (gv, fstypev, devicev);
2512 guestfs_h *g = Guestfs_val (gv);
2514 caml_failwith ("mkfs: used handle after closing it");
2516 const char *fstype = String_val (fstypev);
2517 const char *device = String_val (devicev);
2520 caml_enter_blocking_section ();
2521 r = guestfs_mkfs (g, fstype, device);
2522 caml_leave_blocking_section ();
2524 ocaml_guestfs_raise_error (g, "mkfs");
2531 ocaml_guestfs_sfdisk (value gv, value devicev, value cylsv, value headsv, value sectorsv, value linesv)
2533 CAMLparam5 (gv, devicev, cylsv, headsv, sectorsv);
2534 CAMLxparam1 (linesv);
2537 guestfs_h *g = Guestfs_val (gv);
2539 caml_failwith ("sfdisk: used handle after closing it");
2541 const char *device = String_val (devicev);
2542 int cyls = Int_val (cylsv);
2543 int heads = Int_val (headsv);
2544 int sectors = Int_val (sectorsv);
2545 char **lines = ocaml_guestfs_strings_val (g, linesv);
2548 caml_enter_blocking_section ();
2549 r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2550 caml_leave_blocking_section ();
2551 ocaml_guestfs_free_strings (lines);
2553 ocaml_guestfs_raise_error (g, "sfdisk");
2560 ocaml_guestfs_sfdisk_byte (value *argv, int argn)
2562 return ocaml_guestfs_sfdisk (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4]);
2566 ocaml_guestfs_write_file (value gv, value pathv, value contentv, value sizev)
2568 CAMLparam4 (gv, pathv, contentv, sizev);
2571 guestfs_h *g = Guestfs_val (gv);
2573 caml_failwith ("write_file: used handle after closing it");
2575 const char *path = String_val (pathv);
2576 const char *content = String_val (contentv);
2577 int size = Int_val (sizev);
2580 caml_enter_blocking_section ();
2581 r = guestfs_write_file (g, path, content, size);
2582 caml_leave_blocking_section ();
2584 ocaml_guestfs_raise_error (g, "write_file");
2591 ocaml_guestfs_umount (value gv, value pathordevicev)
2593 CAMLparam2 (gv, pathordevicev);
2596 guestfs_h *g = Guestfs_val (gv);
2598 caml_failwith ("umount: used handle after closing it");
2600 const char *pathordevice = String_val (pathordevicev);
2603 caml_enter_blocking_section ();
2604 r = guestfs_umount (g, pathordevice);
2605 caml_leave_blocking_section ();
2607 ocaml_guestfs_raise_error (g, "umount");
2614 ocaml_guestfs_mounts (value gv)
2619 guestfs_h *g = Guestfs_val (gv);
2621 caml_failwith ("mounts: used handle after closing it");
2626 caml_enter_blocking_section ();
2627 r = guestfs_mounts (g);
2628 caml_leave_blocking_section ();
2630 ocaml_guestfs_raise_error (g, "mounts");
2632 rv = caml_copy_string_array ((const char **) r);
2633 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2639 ocaml_guestfs_umount_all (value gv)
2644 guestfs_h *g = Guestfs_val (gv);
2646 caml_failwith ("umount_all: used handle after closing it");
2650 caml_enter_blocking_section ();
2651 r = guestfs_umount_all (g);
2652 caml_leave_blocking_section ();
2654 ocaml_guestfs_raise_error (g, "umount_all");
2661 ocaml_guestfs_lvm_remove_all (value gv)
2666 guestfs_h *g = Guestfs_val (gv);
2668 caml_failwith ("lvm_remove_all: used handle after closing it");
2672 caml_enter_blocking_section ();
2673 r = guestfs_lvm_remove_all (g);
2674 caml_leave_blocking_section ();
2676 ocaml_guestfs_raise_error (g, "lvm_remove_all");
2683 ocaml_guestfs_file (value gv, value pathv)
2685 CAMLparam2 (gv, pathv);
2688 guestfs_h *g = Guestfs_val (gv);
2690 caml_failwith ("file: used handle after closing it");
2692 const char *path = String_val (pathv);
2695 caml_enter_blocking_section ();
2696 r = guestfs_file (g, path);
2697 caml_leave_blocking_section ();
2699 ocaml_guestfs_raise_error (g, "file");
2701 rv = caml_copy_string (r);
2707 ocaml_guestfs_command (value gv, value argumentsv)
2709 CAMLparam2 (gv, argumentsv);
2712 guestfs_h *g = Guestfs_val (gv);
2714 caml_failwith ("command: used handle after closing it");
2716 char **arguments = ocaml_guestfs_strings_val (g, argumentsv);
2719 caml_enter_blocking_section ();
2720 r = guestfs_command (g, arguments);
2721 caml_leave_blocking_section ();
2722 ocaml_guestfs_free_strings (arguments);
2724 ocaml_guestfs_raise_error (g, "command");
2726 rv = caml_copy_string (r);
2732 ocaml_guestfs_command_lines (value gv, value argumentsv)
2734 CAMLparam2 (gv, argumentsv);
2737 guestfs_h *g = Guestfs_val (gv);
2739 caml_failwith ("command_lines: used handle after closing it");
2741 char **arguments = ocaml_guestfs_strings_val (g, argumentsv);
2745 caml_enter_blocking_section ();
2746 r = guestfs_command_lines (g, arguments);
2747 caml_leave_blocking_section ();
2748 ocaml_guestfs_free_strings (arguments);
2750 ocaml_guestfs_raise_error (g, "command_lines");
2752 rv = caml_copy_string_array ((const char **) r);
2753 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2759 ocaml_guestfs_stat (value gv, value pathv)
2761 CAMLparam2 (gv, pathv);
2764 guestfs_h *g = Guestfs_val (gv);
2766 caml_failwith ("stat: used handle after closing it");
2768 const char *path = String_val (pathv);
2769 struct guestfs_stat *r;
2771 caml_enter_blocking_section ();
2772 r = guestfs_stat (g, path);
2773 caml_leave_blocking_section ();
2775 ocaml_guestfs_raise_error (g, "stat");
2783 ocaml_guestfs_lstat (value gv, value pathv)
2785 CAMLparam2 (gv, pathv);
2788 guestfs_h *g = Guestfs_val (gv);
2790 caml_failwith ("lstat: used handle after closing it");
2792 const char *path = String_val (pathv);
2793 struct guestfs_stat *r;
2795 caml_enter_blocking_section ();
2796 r = guestfs_lstat (g, path);
2797 caml_leave_blocking_section ();
2799 ocaml_guestfs_raise_error (g, "lstat");
2807 ocaml_guestfs_statvfs (value gv, value pathv)
2809 CAMLparam2 (gv, pathv);
2812 guestfs_h *g = Guestfs_val (gv);
2814 caml_failwith ("statvfs: used handle after closing it");
2816 const char *path = String_val (pathv);
2817 struct guestfs_statvfs *r;
2819 caml_enter_blocking_section ();
2820 r = guestfs_statvfs (g, path);
2821 caml_leave_blocking_section ();
2823 ocaml_guestfs_raise_error (g, "statvfs");
2825 rv = copy_statvfs (r);
2831 ocaml_guestfs_tune2fs_l (value gv, value devicev)
2833 CAMLparam2 (gv, devicev);
2836 guestfs_h *g = Guestfs_val (gv);
2838 caml_failwith ("tune2fs_l: used handle after closing it");
2840 const char *device = String_val (devicev);
2844 caml_enter_blocking_section ();
2845 r = guestfs_tune2fs_l (g, device);
2846 caml_leave_blocking_section ();
2848 ocaml_guestfs_raise_error (g, "tune2fs_l");
2850 rv = copy_table (r);
2851 for (i = 0; r[i] != NULL; ++i) free (r[i]);
2857 ocaml_guestfs_blockdev_setro (value gv, value devicev)
2859 CAMLparam2 (gv, devicev);
2862 guestfs_h *g = Guestfs_val (gv);
2864 caml_failwith ("blockdev_setro: used handle after closing it");
2866 const char *device = String_val (devicev);
2869 caml_enter_blocking_section ();
2870 r = guestfs_blockdev_setro (g, device);
2871 caml_leave_blocking_section ();
2873 ocaml_guestfs_raise_error (g, "blockdev_setro");
2880 ocaml_guestfs_blockdev_setrw (value gv, value devicev)
2882 CAMLparam2 (gv, devicev);
2885 guestfs_h *g = Guestfs_val (gv);
2887 caml_failwith ("blockdev_setrw: used handle after closing it");
2889 const char *device = String_val (devicev);
2892 caml_enter_blocking_section ();
2893 r = guestfs_blockdev_setrw (g, device);
2894 caml_leave_blocking_section ();
2896 ocaml_guestfs_raise_error (g, "blockdev_setrw");
2903 ocaml_guestfs_blockdev_getro (value gv, value devicev)
2905 CAMLparam2 (gv, devicev);
2908 guestfs_h *g = Guestfs_val (gv);
2910 caml_failwith ("blockdev_getro: used handle after closing it");
2912 const char *device = String_val (devicev);
2915 caml_enter_blocking_section ();
2916 r = guestfs_blockdev_getro (g, device);
2917 caml_leave_blocking_section ();
2919 ocaml_guestfs_raise_error (g, "blockdev_getro");
2926 ocaml_guestfs_blockdev_getss (value gv, value devicev)
2928 CAMLparam2 (gv, devicev);
2931 guestfs_h *g = Guestfs_val (gv);
2933 caml_failwith ("blockdev_getss: used handle after closing it");
2935 const char *device = String_val (devicev);
2938 caml_enter_blocking_section ();
2939 r = guestfs_blockdev_getss (g, device);
2940 caml_leave_blocking_section ();
2942 ocaml_guestfs_raise_error (g, "blockdev_getss");
2949 ocaml_guestfs_blockdev_getbsz (value gv, value devicev)
2951 CAMLparam2 (gv, devicev);
2954 guestfs_h *g = Guestfs_val (gv);
2956 caml_failwith ("blockdev_getbsz: used handle after closing it");
2958 const char *device = String_val (devicev);
2961 caml_enter_blocking_section ();
2962 r = guestfs_blockdev_getbsz (g, device);
2963 caml_leave_blocking_section ();
2965 ocaml_guestfs_raise_error (g, "blockdev_getbsz");
2972 ocaml_guestfs_blockdev_setbsz (value gv, value devicev, value blocksizev)
2974 CAMLparam3 (gv, devicev, blocksizev);
2977 guestfs_h *g = Guestfs_val (gv);
2979 caml_failwith ("blockdev_setbsz: used handle after closing it");
2981 const char *device = String_val (devicev);
2982 int blocksize = Int_val (blocksizev);
2985 caml_enter_blocking_section ();
2986 r = guestfs_blockdev_setbsz (g, device, blocksize);
2987 caml_leave_blocking_section ();
2989 ocaml_guestfs_raise_error (g, "blockdev_setbsz");
2996 ocaml_guestfs_blockdev_getsz (value gv, value devicev)
2998 CAMLparam2 (gv, devicev);
3001 guestfs_h *g = Guestfs_val (gv);
3003 caml_failwith ("blockdev_getsz: used handle after closing it");
3005 const char *device = String_val (devicev);
3008 caml_enter_blocking_section ();
3009 r = guestfs_blockdev_getsz (g, device);
3010 caml_leave_blocking_section ();
3012 ocaml_guestfs_raise_error (g, "blockdev_getsz");
3014 rv = caml_copy_int64 (r);
3019 ocaml_guestfs_blockdev_getsize64 (value gv, value devicev)
3021 CAMLparam2 (gv, devicev);
3024 guestfs_h *g = Guestfs_val (gv);
3026 caml_failwith ("blockdev_getsize64: used handle after closing it");
3028 const char *device = String_val (devicev);
3031 caml_enter_blocking_section ();
3032 r = guestfs_blockdev_getsize64 (g, device);
3033 caml_leave_blocking_section ();
3035 ocaml_guestfs_raise_error (g, "blockdev_getsize64");
3037 rv = caml_copy_int64 (r);
3042 ocaml_guestfs_blockdev_flushbufs (value gv, value devicev)
3044 CAMLparam2 (gv, devicev);
3047 guestfs_h *g = Guestfs_val (gv);
3049 caml_failwith ("blockdev_flushbufs: used handle after closing it");
3051 const char *device = String_val (devicev);
3054 caml_enter_blocking_section ();
3055 r = guestfs_blockdev_flushbufs (g, device);
3056 caml_leave_blocking_section ();
3058 ocaml_guestfs_raise_error (g, "blockdev_flushbufs");
3065 ocaml_guestfs_blockdev_rereadpt (value gv, value devicev)
3067 CAMLparam2 (gv, devicev);
3070 guestfs_h *g = Guestfs_val (gv);
3072 caml_failwith ("blockdev_rereadpt: used handle after closing it");
3074 const char *device = String_val (devicev);
3077 caml_enter_blocking_section ();
3078 r = guestfs_blockdev_rereadpt (g, device);
3079 caml_leave_blocking_section ();
3081 ocaml_guestfs_raise_error (g, "blockdev_rereadpt");
3088 ocaml_guestfs_upload (value gv, value filenamev, value remotefilenamev)
3090 CAMLparam3 (gv, filenamev, remotefilenamev);
3093 guestfs_h *g = Guestfs_val (gv);
3095 caml_failwith ("upload: used handle after closing it");
3097 const char *filename = String_val (filenamev);
3098 const char *remotefilename = String_val (remotefilenamev);
3101 caml_enter_blocking_section ();
3102 r = guestfs_upload (g, filename, remotefilename);
3103 caml_leave_blocking_section ();
3105 ocaml_guestfs_raise_error (g, "upload");
3112 ocaml_guestfs_download (value gv, value remotefilenamev, value filenamev)
3114 CAMLparam3 (gv, remotefilenamev, filenamev);
3117 guestfs_h *g = Guestfs_val (gv);
3119 caml_failwith ("download: used handle after closing it");
3121 const char *remotefilename = String_val (remotefilenamev);
3122 const char *filename = String_val (filenamev);
3125 caml_enter_blocking_section ();
3126 r = guestfs_download (g, remotefilename, filename);
3127 caml_leave_blocking_section ();
3129 ocaml_guestfs_raise_error (g, "download");
3136 ocaml_guestfs_checksum (value gv, value csumtypev, value pathv)
3138 CAMLparam3 (gv, csumtypev, pathv);
3141 guestfs_h *g = Guestfs_val (gv);
3143 caml_failwith ("checksum: used handle after closing it");
3145 const char *csumtype = String_val (csumtypev);
3146 const char *path = String_val (pathv);
3149 caml_enter_blocking_section ();
3150 r = guestfs_checksum (g, csumtype, path);
3151 caml_leave_blocking_section ();
3153 ocaml_guestfs_raise_error (g, "checksum");
3155 rv = caml_copy_string (r);
3161 ocaml_guestfs_tar_in (value gv, value tarfilev, value directoryv)
3163 CAMLparam3 (gv, tarfilev, directoryv);
3166 guestfs_h *g = Guestfs_val (gv);
3168 caml_failwith ("tar_in: used handle after closing it");
3170 const char *tarfile = String_val (tarfilev);
3171 const char *directory = String_val (directoryv);
3174 caml_enter_blocking_section ();
3175 r = guestfs_tar_in (g, tarfile, directory);
3176 caml_leave_blocking_section ();
3178 ocaml_guestfs_raise_error (g, "tar_in");
3185 ocaml_guestfs_tar_out (value gv, value directoryv, value tarfilev)
3187 CAMLparam3 (gv, directoryv, tarfilev);
3190 guestfs_h *g = Guestfs_val (gv);
3192 caml_failwith ("tar_out: used handle after closing it");
3194 const char *directory = String_val (directoryv);
3195 const char *tarfile = String_val (tarfilev);
3198 caml_enter_blocking_section ();
3199 r = guestfs_tar_out (g, directory, tarfile);
3200 caml_leave_blocking_section ();
3202 ocaml_guestfs_raise_error (g, "tar_out");
3209 ocaml_guestfs_tgz_in (value gv, value tarballv, value directoryv)
3211 CAMLparam3 (gv, tarballv, directoryv);
3214 guestfs_h *g = Guestfs_val (gv);
3216 caml_failwith ("tgz_in: used handle after closing it");
3218 const char *tarball = String_val (tarballv);
3219 const char *directory = String_val (directoryv);
3222 caml_enter_blocking_section ();
3223 r = guestfs_tgz_in (g, tarball, directory);
3224 caml_leave_blocking_section ();
3226 ocaml_guestfs_raise_error (g, "tgz_in");
3233 ocaml_guestfs_tgz_out (value gv, value directoryv, value tarballv)
3235 CAMLparam3 (gv, directoryv, tarballv);
3238 guestfs_h *g = Guestfs_val (gv);
3240 caml_failwith ("tgz_out: used handle after closing it");
3242 const char *directory = String_val (directoryv);
3243 const char *tarball = String_val (tarballv);
3246 caml_enter_blocking_section ();
3247 r = guestfs_tgz_out (g, directory, tarball);
3248 caml_leave_blocking_section ();
3250 ocaml_guestfs_raise_error (g, "tgz_out");
3257 ocaml_guestfs_mount_ro (value gv, value devicev, value mountpointv)
3259 CAMLparam3 (gv, devicev, mountpointv);
3262 guestfs_h *g = Guestfs_val (gv);
3264 caml_failwith ("mount_ro: used handle after closing it");
3266 const char *device = String_val (devicev);
3267 const char *mountpoint = String_val (mountpointv);
3270 caml_enter_blocking_section ();
3271 r = guestfs_mount_ro (g, device, mountpoint);
3272 caml_leave_blocking_section ();
3274 ocaml_guestfs_raise_error (g, "mount_ro");
3281 ocaml_guestfs_mount_options (value gv, value optionsv, value devicev, value mountpointv)
3283 CAMLparam4 (gv, optionsv, devicev, mountpointv);
3286 guestfs_h *g = Guestfs_val (gv);
3288 caml_failwith ("mount_options: used handle after closing it");
3290 const char *options = String_val (optionsv);
3291 const char *device = String_val (devicev);
3292 const char *mountpoint = String_val (mountpointv);
3295 caml_enter_blocking_section ();
3296 r = guestfs_mount_options (g, options, device, mountpoint);
3297 caml_leave_blocking_section ();
3299 ocaml_guestfs_raise_error (g, "mount_options");
3306 ocaml_guestfs_mount_vfs (value gv, value optionsv, value vfstypev, value devicev, value mountpointv)
3308 CAMLparam5 (gv, optionsv, vfstypev, devicev, mountpointv);
3311 guestfs_h *g = Guestfs_val (gv);
3313 caml_failwith ("mount_vfs: used handle after closing it");
3315 const char *options = String_val (optionsv);
3316 const char *vfstype = String_val (vfstypev);
3317 const char *device = String_val (devicev);
3318 const char *mountpoint = String_val (mountpointv);
3321 caml_enter_blocking_section ();
3322 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3323 caml_leave_blocking_section ();
3325 ocaml_guestfs_raise_error (g, "mount_vfs");
3332 ocaml_guestfs_debug (value gv, value subcmdv, value extraargsv)
3334 CAMLparam3 (gv, subcmdv, extraargsv);
3337 guestfs_h *g = Guestfs_val (gv);
3339 caml_failwith ("debug: used handle after closing it");
3341 const char *subcmd = String_val (subcmdv);
3342 char **extraargs = ocaml_guestfs_strings_val (g, extraargsv);
3345 caml_enter_blocking_section ();
3346 r = guestfs_debug (g, subcmd, extraargs);
3347 caml_leave_blocking_section ();
3348 ocaml_guestfs_free_strings (extraargs);
3350 ocaml_guestfs_raise_error (g, "debug");
3352 rv = caml_copy_string (r);
3358 ocaml_guestfs_lvremove (value gv, value devicev)
3360 CAMLparam2 (gv, devicev);
3363 guestfs_h *g = Guestfs_val (gv);
3365 caml_failwith ("lvremove: used handle after closing it");
3367 const char *device = String_val (devicev);
3370 caml_enter_blocking_section ();
3371 r = guestfs_lvremove (g, device);
3372 caml_leave_blocking_section ();
3374 ocaml_guestfs_raise_error (g, "lvremove");
3381 ocaml_guestfs_vgremove (value gv, value vgnamev)
3383 CAMLparam2 (gv, vgnamev);
3386 guestfs_h *g = Guestfs_val (gv);
3388 caml_failwith ("vgremove: used handle after closing it");
3390 const char *vgname = String_val (vgnamev);
3393 caml_enter_blocking_section ();
3394 r = guestfs_vgremove (g, vgname);
3395 caml_leave_blocking_section ();
3397 ocaml_guestfs_raise_error (g, "vgremove");
3404 ocaml_guestfs_pvremove (value gv, value devicev)
3406 CAMLparam2 (gv, devicev);
3409 guestfs_h *g = Guestfs_val (gv);
3411 caml_failwith ("pvremove: used handle after closing it");
3413 const char *device = String_val (devicev);
3416 caml_enter_blocking_section ();
3417 r = guestfs_pvremove (g, device);
3418 caml_leave_blocking_section ();
3420 ocaml_guestfs_raise_error (g, "pvremove");
3427 ocaml_guestfs_set_e2label (value gv, value devicev, value labelv)
3429 CAMLparam3 (gv, devicev, labelv);
3432 guestfs_h *g = Guestfs_val (gv);
3434 caml_failwith ("set_e2label: used handle after closing it");
3436 const char *device = String_val (devicev);
3437 const char *label = String_val (labelv);
3440 caml_enter_blocking_section ();
3441 r = guestfs_set_e2label (g, device, label);
3442 caml_leave_blocking_section ();
3444 ocaml_guestfs_raise_error (g, "set_e2label");
3451 ocaml_guestfs_get_e2label (value gv, value devicev)
3453 CAMLparam2 (gv, devicev);
3456 guestfs_h *g = Guestfs_val (gv);
3458 caml_failwith ("get_e2label: used handle after closing it");
3460 const char *device = String_val (devicev);
3463 caml_enter_blocking_section ();
3464 r = guestfs_get_e2label (g, device);
3465 caml_leave_blocking_section ();
3467 ocaml_guestfs_raise_error (g, "get_e2label");
3469 rv = caml_copy_string (r);
3475 ocaml_guestfs_set_e2uuid (value gv, value devicev, value uuidv)
3477 CAMLparam3 (gv, devicev, uuidv);
3480 guestfs_h *g = Guestfs_val (gv);
3482 caml_failwith ("set_e2uuid: used handle after closing it");
3484 const char *device = String_val (devicev);
3485 const char *uuid = String_val (uuidv);
3488 caml_enter_blocking_section ();
3489 r = guestfs_set_e2uuid (g, device, uuid);
3490 caml_leave_blocking_section ();
3492 ocaml_guestfs_raise_error (g, "set_e2uuid");
3499 ocaml_guestfs_get_e2uuid (value gv, value devicev)
3501 CAMLparam2 (gv, devicev);
3504 guestfs_h *g = Guestfs_val (gv);
3506 caml_failwith ("get_e2uuid: used handle after closing it");
3508 const char *device = String_val (devicev);
3511 caml_enter_blocking_section ();
3512 r = guestfs_get_e2uuid (g, device);
3513 caml_leave_blocking_section ();
3515 ocaml_guestfs_raise_error (g, "get_e2uuid");
3517 rv = caml_copy_string (r);
3523 ocaml_guestfs_fsck (value gv, value fstypev, value devicev)
3525 CAMLparam3 (gv, fstypev, devicev);
3528 guestfs_h *g = Guestfs_val (gv);
3530 caml_failwith ("fsck: used handle after closing it");
3532 const char *fstype = String_val (fstypev);
3533 const char *device = String_val (devicev);
3536 caml_enter_blocking_section ();
3537 r = guestfs_fsck (g, fstype, device);
3538 caml_leave_blocking_section ();
3540 ocaml_guestfs_raise_error (g, "fsck");
3547 ocaml_guestfs_zero (value gv, value devicev)
3549 CAMLparam2 (gv, devicev);
3552 guestfs_h *g = Guestfs_val (gv);
3554 caml_failwith ("zero: used handle after closing it");
3556 const char *device = String_val (devicev);
3559 caml_enter_blocking_section ();
3560 r = guestfs_zero (g, device);
3561 caml_leave_blocking_section ();
3563 ocaml_guestfs_raise_error (g, "zero");
3570 ocaml_guestfs_grub_install (value gv, value rootv, value devicev)
3572 CAMLparam3 (gv, rootv, devicev);
3575 guestfs_h *g = Guestfs_val (gv);
3577 caml_failwith ("grub_install: used handle after closing it");
3579 const char *root = String_val (rootv);
3580 const char *device = String_val (devicev);
3583 caml_enter_blocking_section ();
3584 r = guestfs_grub_install (g, root, device);
3585 caml_leave_blocking_section ();
3587 ocaml_guestfs_raise_error (g, "grub_install");
3594 ocaml_guestfs_cp (value gv, value srcv, value destv)
3596 CAMLparam3 (gv, srcv, destv);
3599 guestfs_h *g = Guestfs_val (gv);
3601 caml_failwith ("cp: used handle after closing it");
3603 const char *src = String_val (srcv);
3604 const char *dest = String_val (destv);
3607 caml_enter_blocking_section ();
3608 r = guestfs_cp (g, src, dest);
3609 caml_leave_blocking_section ();
3611 ocaml_guestfs_raise_error (g, "cp");
3618 ocaml_guestfs_cp_a (value gv, value srcv, value destv)
3620 CAMLparam3 (gv, srcv, destv);
3623 guestfs_h *g = Guestfs_val (gv);
3625 caml_failwith ("cp_a: used handle after closing it");
3627 const char *src = String_val (srcv);
3628 const char *dest = String_val (destv);
3631 caml_enter_blocking_section ();
3632 r = guestfs_cp_a (g, src, dest);
3633 caml_leave_blocking_section ();
3635 ocaml_guestfs_raise_error (g, "cp_a");
3642 ocaml_guestfs_mv (value gv, value srcv, value destv)
3644 CAMLparam3 (gv, srcv, destv);
3647 guestfs_h *g = Guestfs_val (gv);
3649 caml_failwith ("mv: used handle after closing it");
3651 const char *src = String_val (srcv);
3652 const char *dest = String_val (destv);
3655 caml_enter_blocking_section ();
3656 r = guestfs_mv (g, src, dest);
3657 caml_leave_blocking_section ();
3659 ocaml_guestfs_raise_error (g, "mv");
3666 ocaml_guestfs_drop_caches (value gv, value whattodropv)
3668 CAMLparam2 (gv, whattodropv);
3671 guestfs_h *g = Guestfs_val (gv);
3673 caml_failwith ("drop_caches: used handle after closing it");
3675 int whattodrop = Int_val (whattodropv);
3678 caml_enter_blocking_section ();
3679 r = guestfs_drop_caches (g, whattodrop);
3680 caml_leave_blocking_section ();
3682 ocaml_guestfs_raise_error (g, "drop_caches");
3689 ocaml_guestfs_dmesg (value gv)
3694 guestfs_h *g = Guestfs_val (gv);
3696 caml_failwith ("dmesg: used handle after closing it");
3700 caml_enter_blocking_section ();
3701 r = guestfs_dmesg (g);
3702 caml_leave_blocking_section ();
3704 ocaml_guestfs_raise_error (g, "dmesg");
3706 rv = caml_copy_string (r);
3712 ocaml_guestfs_ping_daemon (value gv)
3717 guestfs_h *g = Guestfs_val (gv);
3719 caml_failwith ("ping_daemon: used handle after closing it");
3723 caml_enter_blocking_section ();
3724 r = guestfs_ping_daemon (g);
3725 caml_leave_blocking_section ();
3727 ocaml_guestfs_raise_error (g, "ping_daemon");
3734 ocaml_guestfs_equal (value gv, value file1v, value file2v)
3736 CAMLparam3 (gv, file1v, file2v);
3739 guestfs_h *g = Guestfs_val (gv);
3741 caml_failwith ("equal: used handle after closing it");
3743 const char *file1 = String_val (file1v);
3744 const char *file2 = String_val (file2v);
3747 caml_enter_blocking_section ();
3748 r = guestfs_equal (g, file1, file2);
3749 caml_leave_blocking_section ();
3751 ocaml_guestfs_raise_error (g, "equal");
3758 ocaml_guestfs_strings (value gv, value pathv)
3760 CAMLparam2 (gv, pathv);
3763 guestfs_h *g = Guestfs_val (gv);
3765 caml_failwith ("strings: used handle after closing it");
3767 const char *path = String_val (pathv);
3771 caml_enter_blocking_section ();
3772 r = guestfs_strings (g, path);
3773 caml_leave_blocking_section ();
3775 ocaml_guestfs_raise_error (g, "strings");
3777 rv = caml_copy_string_array ((const char **) r);
3778 for (i = 0; r[i] != NULL; ++i) free (r[i]);
3784 ocaml_guestfs_strings_e (value gv, value encodingv, value pathv)
3786 CAMLparam3 (gv, encodingv, pathv);
3789 guestfs_h *g = Guestfs_val (gv);
3791 caml_failwith ("strings_e: used handle after closing it");
3793 const char *encoding = String_val (encodingv);
3794 const char *path = String_val (pathv);
3798 caml_enter_blocking_section ();
3799 r = guestfs_strings_e (g, encoding, path);
3800 caml_leave_blocking_section ();
3802 ocaml_guestfs_raise_error (g, "strings_e");
3804 rv = caml_copy_string_array ((const char **) r);
3805 for (i = 0; r[i] != NULL; ++i) free (r[i]);
3811 ocaml_guestfs_hexdump (value gv, value pathv)
3813 CAMLparam2 (gv, pathv);
3816 guestfs_h *g = Guestfs_val (gv);
3818 caml_failwith ("hexdump: used handle after closing it");
3820 const char *path = String_val (pathv);
3823 caml_enter_blocking_section ();
3824 r = guestfs_hexdump (g, path);
3825 caml_leave_blocking_section ();
3827 ocaml_guestfs_raise_error (g, "hexdump");
3829 rv = caml_copy_string (r);
3835 ocaml_guestfs_zerofree (value gv, value devicev)
3837 CAMLparam2 (gv, devicev);
3840 guestfs_h *g = Guestfs_val (gv);
3842 caml_failwith ("zerofree: used handle after closing it");
3844 const char *device = String_val (devicev);
3847 caml_enter_blocking_section ();
3848 r = guestfs_zerofree (g, device);
3849 caml_leave_blocking_section ();
3851 ocaml_guestfs_raise_error (g, "zerofree");
3858 ocaml_guestfs_pvresize (value gv, value devicev)
3860 CAMLparam2 (gv, devicev);
3863 guestfs_h *g = Guestfs_val (gv);
3865 caml_failwith ("pvresize: used handle after closing it");
3867 const char *device = String_val (devicev);
3870 caml_enter_blocking_section ();
3871 r = guestfs_pvresize (g, device);
3872 caml_leave_blocking_section ();
3874 ocaml_guestfs_raise_error (g, "pvresize");
3881 ocaml_guestfs_sfdisk_N (value gv, value devicev, value nv, value cylsv, value headsv, value sectorsv, value linev)
3883 CAMLparam5 (gv, devicev, nv, cylsv, headsv);
3884 CAMLxparam2 (sectorsv, linev);
3887 guestfs_h *g = Guestfs_val (gv);
3889 caml_failwith ("sfdisk_N: used handle after closing it");
3891 const char *device = String_val (devicev);
3892 int n = Int_val (nv);
3893 int cyls = Int_val (cylsv);
3894 int heads = Int_val (headsv);
3895 int sectors = Int_val (sectorsv);
3896 const char *line = String_val (linev);
3899 caml_enter_blocking_section ();
3900 r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
3901 caml_leave_blocking_section ();
3903 ocaml_guestfs_raise_error (g, "sfdisk_N");
3910 ocaml_guestfs_sfdisk_N_byte (value *argv, int argn)
3912 return ocaml_guestfs_sfdisk_N (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
3916 ocaml_guestfs_sfdisk_l (value gv, value devicev)
3918 CAMLparam2 (gv, devicev);
3921 guestfs_h *g = Guestfs_val (gv);
3923 caml_failwith ("sfdisk_l: used handle after closing it");
3925 const char *device = String_val (devicev);
3928 caml_enter_blocking_section ();
3929 r = guestfs_sfdisk_l (g, device);
3930 caml_leave_blocking_section ();
3932 ocaml_guestfs_raise_error (g, "sfdisk_l");
3934 rv = caml_copy_string (r);
3940 ocaml_guestfs_sfdisk_kernel_geometry (value gv, value devicev)
3942 CAMLparam2 (gv, devicev);
3945 guestfs_h *g = Guestfs_val (gv);
3947 caml_failwith ("sfdisk_kernel_geometry: used handle after closing it");
3949 const char *device = String_val (devicev);
3952 caml_enter_blocking_section ();
3953 r = guestfs_sfdisk_kernel_geometry (g, device);
3954 caml_leave_blocking_section ();
3956 ocaml_guestfs_raise_error (g, "sfdisk_kernel_geometry");
3958 rv = caml_copy_string (r);
3964 ocaml_guestfs_sfdisk_disk_geometry (value gv, value devicev)
3966 CAMLparam2 (gv, devicev);
3969 guestfs_h *g = Guestfs_val (gv);
3971 caml_failwith ("sfdisk_disk_geometry: used handle after closing it");
3973 const char *device = String_val (devicev);
3976 caml_enter_blocking_section ();
3977 r = guestfs_sfdisk_disk_geometry (g, device);
3978 caml_leave_blocking_section ();
3980 ocaml_guestfs_raise_error (g, "sfdisk_disk_geometry");
3982 rv = caml_copy_string (r);
3988 ocaml_guestfs_vg_activate_all (value gv, value activatev)
3990 CAMLparam2 (gv, activatev);
3993 guestfs_h *g = Guestfs_val (gv);
3995 caml_failwith ("vg_activate_all: used handle after closing it");
3997 int activate = Bool_val (activatev);
4000 caml_enter_blocking_section ();
4001 r = guestfs_vg_activate_all (g, activate);
4002 caml_leave_blocking_section ();
4004 ocaml_guestfs_raise_error (g, "vg_activate_all");
4011 ocaml_guestfs_vg_activate (value gv, value activatev, value volgroupsv)
4013 CAMLparam3 (gv, activatev, volgroupsv);
4016 guestfs_h *g = Guestfs_val (gv);
4018 caml_failwith ("vg_activate: used handle after closing it");
4020 int activate = Bool_val (activatev);
4021 char **volgroups = ocaml_guestfs_strings_val (g, volgroupsv);
4024 caml_enter_blocking_section ();
4025 r = guestfs_vg_activate (g, activate, volgroups);
4026 caml_leave_blocking_section ();
4027 ocaml_guestfs_free_strings (volgroups);
4029 ocaml_guestfs_raise_error (g, "vg_activate");
4036 ocaml_guestfs_lvresize (value gv, value devicev, value mbytesv)
4038 CAMLparam3 (gv, devicev, mbytesv);
4041 guestfs_h *g = Guestfs_val (gv);
4043 caml_failwith ("lvresize: used handle after closing it");
4045 const char *device = String_val (devicev);
4046 int mbytes = Int_val (mbytesv);
4049 caml_enter_blocking_section ();
4050 r = guestfs_lvresize (g, device, mbytes);
4051 caml_leave_blocking_section ();
4053 ocaml_guestfs_raise_error (g, "lvresize");
4060 ocaml_guestfs_resize2fs (value gv, value devicev)
4062 CAMLparam2 (gv, devicev);
4065 guestfs_h *g = Guestfs_val (gv);
4067 caml_failwith ("resize2fs: used handle after closing it");
4069 const char *device = String_val (devicev);
4072 caml_enter_blocking_section ();
4073 r = guestfs_resize2fs (g, device);
4074 caml_leave_blocking_section ();
4076 ocaml_guestfs_raise_error (g, "resize2fs");
4083 ocaml_guestfs_find (value gv, value directoryv)
4085 CAMLparam2 (gv, directoryv);
4088 guestfs_h *g = Guestfs_val (gv);
4090 caml_failwith ("find: used handle after closing it");
4092 const char *directory = String_val (directoryv);
4096 caml_enter_blocking_section ();
4097 r = guestfs_find (g, directory);
4098 caml_leave_blocking_section ();
4100 ocaml_guestfs_raise_error (g, "find");
4102 rv = caml_copy_string_array ((const char **) r);
4103 for (i = 0; r[i] != NULL; ++i) free (r[i]);
4109 ocaml_guestfs_e2fsck_f (value gv, value devicev)
4111 CAMLparam2 (gv, devicev);
4114 guestfs_h *g = Guestfs_val (gv);
4116 caml_failwith ("e2fsck_f: used handle after closing it");
4118 const char *device = String_val (devicev);
4121 caml_enter_blocking_section ();
4122 r = guestfs_e2fsck_f (g, device);
4123 caml_leave_blocking_section ();
4125 ocaml_guestfs_raise_error (g, "e2fsck_f");