Add the test0* functions, used to test language bindings.
[libguestfs.git] / ocaml / guestfs_c_actions.c
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.
4  *
5  * Copyright (C) 2009 Red Hat Inc.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
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>
33
34 #include <guestfs.h>
35
36 #include "guestfs_c.h"
37
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
40  * ordered anyway.
41  */
42 static CAMLprim value
43 copy_table (char * const * argv)
44 {
45   CAMLparam0 ();
46   CAMLlocal5 (rv, pairv, kv, vv, cons);
47   int i;
48
49   rv = Val_int (0);
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);
58     rv = cons;
59     Store_field (cons, 0, pairv);
60   }
61
62   CAMLreturn (rv);
63 }
64
65 static CAMLprim value
66 copy_lvm_pv (const struct guestfs_lvm_pv *pv)
67 {
68   CAMLparam0 ();
69   CAMLlocal2 (rv, v);
70
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);
101   CAMLreturn (rv);
102 }
103
104 static CAMLprim value
105 copy_lvm_pv_list (const struct guestfs_lvm_pv_list *pvs)
106 {
107   CAMLparam0 ();
108   CAMLlocal2 (rv, v);
109   int i;
110
111   if (pvs->len == 0)
112     CAMLreturn (Atom (0));
113   else {
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);
118     }
119     CAMLreturn (rv);
120   }
121 }
122
123 static CAMLprim value
124 copy_lvm_vg (const struct guestfs_lvm_vg *vg)
125 {
126   CAMLparam0 ();
127   CAMLlocal2 (rv, v);
128
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);
169   CAMLreturn (rv);
170 }
171
172 static CAMLprim value
173 copy_lvm_vg_list (const struct guestfs_lvm_vg_list *vgs)
174 {
175   CAMLparam0 ();
176   CAMLlocal2 (rv, v);
177   int i;
178
179   if (vgs->len == 0)
180     CAMLreturn (Atom (0));
181   else {
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);
186     }
187     CAMLreturn (rv);
188   }
189 }
190
191 static CAMLprim value
192 copy_lvm_lv (const struct guestfs_lvm_lv *lv)
193 {
194   CAMLparam0 ();
195   CAMLlocal3 (rv, v, v2);
196
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);
223   } else /* None */
224     v = Val_int (0);
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);
230   } else /* None */
231     v = Val_int (0);
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);
241   CAMLreturn (rv);
242 }
243
244 static CAMLprim value
245 copy_lvm_lv_list (const struct guestfs_lvm_lv_list *lvs)
246 {
247   CAMLparam0 ();
248   CAMLlocal2 (rv, v);
249   int i;
250
251   if (lvs->len == 0)
252     CAMLreturn (Atom (0));
253   else {
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);
258     }
259     CAMLreturn (rv);
260   }
261 }
262
263 static CAMLprim value
264 copy_stat (const struct guestfs_stat *stat)
265 {
266   CAMLparam0 ();
267   CAMLlocal2 (rv, v);
268
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);
296   CAMLreturn (rv);
297 }
298
299 static CAMLprim value
300 copy_statvfs (const struct guestfs_statvfs *statvfs)
301 {
302   CAMLparam0 ();
303   CAMLlocal2 (rv, v);
304
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);
328   CAMLreturn (rv);
329 }
330
331 CAMLprim value
332 ocaml_guestfs_test0 (value gv, value strv, value optstrv, value strlistv, value bv, value integerv, value fileinv, value fileoutv)
333 {
334   CAMLparam5 (gv, strv, optstrv, strlistv, bv);
335   CAMLxparam3 (integerv, fileinv, fileoutv);
336   CAMLlocal1 (rv);
337
338   guestfs_h *g = Guestfs_val (gv);
339   if (g == NULL)
340     caml_failwith ("test0: used handle after closing it");
341
342   const char *str = String_val (strv);
343   const char *optstr =
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);
350   int r;
351
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);
356   if (r == -1)
357     ocaml_guestfs_raise_error (g, "test0");
358
359   rv = Val_unit;
360   CAMLreturn (rv);
361 }
362
363 CAMLprim value
364 ocaml_guestfs_test0_byte (value *argv, int argn)
365 {
366   return ocaml_guestfs_test0 (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
367 }
368
369 CAMLprim value
370 ocaml_guestfs_test0rint (value gv, value valv)
371 {
372   CAMLparam2 (gv, valv);
373   CAMLlocal1 (rv);
374
375   guestfs_h *g = Guestfs_val (gv);
376   if (g == NULL)
377     caml_failwith ("test0rint: used handle after closing it");
378
379   const char *val = String_val (valv);
380   int r;
381
382   caml_enter_blocking_section ();
383   r = guestfs_test0rint (g, val);
384   caml_leave_blocking_section ();
385   if (r == -1)
386     ocaml_guestfs_raise_error (g, "test0rint");
387
388   rv = Val_int (r);
389   CAMLreturn (rv);
390 }
391
392 CAMLprim value
393 ocaml_guestfs_test0rinterr (value gv)
394 {
395   CAMLparam1 (gv);
396   CAMLlocal1 (rv);
397
398   guestfs_h *g = Guestfs_val (gv);
399   if (g == NULL)
400     caml_failwith ("test0rinterr: used handle after closing it");
401
402   int r;
403
404   caml_enter_blocking_section ();
405   r = guestfs_test0rinterr (g);
406   caml_leave_blocking_section ();
407   if (r == -1)
408     ocaml_guestfs_raise_error (g, "test0rinterr");
409
410   rv = Val_int (r);
411   CAMLreturn (rv);
412 }
413
414 CAMLprim value
415 ocaml_guestfs_test0rint64 (value gv, value valv)
416 {
417   CAMLparam2 (gv, valv);
418   CAMLlocal1 (rv);
419
420   guestfs_h *g = Guestfs_val (gv);
421   if (g == NULL)
422     caml_failwith ("test0rint64: used handle after closing it");
423
424   const char *val = String_val (valv);
425   int64_t r;
426
427   caml_enter_blocking_section ();
428   r = guestfs_test0rint64 (g, val);
429   caml_leave_blocking_section ();
430   if (r == -1)
431     ocaml_guestfs_raise_error (g, "test0rint64");
432
433   rv = caml_copy_int64 (r);
434   CAMLreturn (rv);
435 }
436
437 CAMLprim value
438 ocaml_guestfs_test0rint64err (value gv)
439 {
440   CAMLparam1 (gv);
441   CAMLlocal1 (rv);
442
443   guestfs_h *g = Guestfs_val (gv);
444   if (g == NULL)
445     caml_failwith ("test0rint64err: used handle after closing it");
446
447   int64_t r;
448
449   caml_enter_blocking_section ();
450   r = guestfs_test0rint64err (g);
451   caml_leave_blocking_section ();
452   if (r == -1)
453     ocaml_guestfs_raise_error (g, "test0rint64err");
454
455   rv = caml_copy_int64 (r);
456   CAMLreturn (rv);
457 }
458
459 CAMLprim value
460 ocaml_guestfs_test0rbool (value gv, value valv)
461 {
462   CAMLparam2 (gv, valv);
463   CAMLlocal1 (rv);
464
465   guestfs_h *g = Guestfs_val (gv);
466   if (g == NULL)
467     caml_failwith ("test0rbool: used handle after closing it");
468
469   const char *val = String_val (valv);
470   int r;
471
472   caml_enter_blocking_section ();
473   r = guestfs_test0rbool (g, val);
474   caml_leave_blocking_section ();
475   if (r == -1)
476     ocaml_guestfs_raise_error (g, "test0rbool");
477
478   rv = Val_bool (r);
479   CAMLreturn (rv);
480 }
481
482 CAMLprim value
483 ocaml_guestfs_test0rboolerr (value gv)
484 {
485   CAMLparam1 (gv);
486   CAMLlocal1 (rv);
487
488   guestfs_h *g = Guestfs_val (gv);
489   if (g == NULL)
490     caml_failwith ("test0rboolerr: used handle after closing it");
491
492   int r;
493
494   caml_enter_blocking_section ();
495   r = guestfs_test0rboolerr (g);
496   caml_leave_blocking_section ();
497   if (r == -1)
498     ocaml_guestfs_raise_error (g, "test0rboolerr");
499
500   rv = Val_bool (r);
501   CAMLreturn (rv);
502 }
503
504 CAMLprim value
505 ocaml_guestfs_test0rconststring (value gv, value valv)
506 {
507   CAMLparam2 (gv, valv);
508   CAMLlocal1 (rv);
509
510   guestfs_h *g = Guestfs_val (gv);
511   if (g == NULL)
512     caml_failwith ("test0rconststring: used handle after closing it");
513
514   const char *val = String_val (valv);
515   const char *r;
516
517   caml_enter_blocking_section ();
518   r = guestfs_test0rconststring (g, val);
519   caml_leave_blocking_section ();
520   if (r == NULL)
521     ocaml_guestfs_raise_error (g, "test0rconststring");
522
523   rv = caml_copy_string (r);
524   CAMLreturn (rv);
525 }
526
527 CAMLprim value
528 ocaml_guestfs_test0rconststringerr (value gv)
529 {
530   CAMLparam1 (gv);
531   CAMLlocal1 (rv);
532
533   guestfs_h *g = Guestfs_val (gv);
534   if (g == NULL)
535     caml_failwith ("test0rconststringerr: used handle after closing it");
536
537   const char *r;
538
539   caml_enter_blocking_section ();
540   r = guestfs_test0rconststringerr (g);
541   caml_leave_blocking_section ();
542   if (r == NULL)
543     ocaml_guestfs_raise_error (g, "test0rconststringerr");
544
545   rv = caml_copy_string (r);
546   CAMLreturn (rv);
547 }
548
549 CAMLprim value
550 ocaml_guestfs_test0rstring (value gv, value valv)
551 {
552   CAMLparam2 (gv, valv);
553   CAMLlocal1 (rv);
554
555   guestfs_h *g = Guestfs_val (gv);
556   if (g == NULL)
557     caml_failwith ("test0rstring: used handle after closing it");
558
559   const char *val = String_val (valv);
560   char *r;
561
562   caml_enter_blocking_section ();
563   r = guestfs_test0rstring (g, val);
564   caml_leave_blocking_section ();
565   if (r == NULL)
566     ocaml_guestfs_raise_error (g, "test0rstring");
567
568   rv = caml_copy_string (r);
569   free (r);
570   CAMLreturn (rv);
571 }
572
573 CAMLprim value
574 ocaml_guestfs_test0rstringerr (value gv)
575 {
576   CAMLparam1 (gv);
577   CAMLlocal1 (rv);
578
579   guestfs_h *g = Guestfs_val (gv);
580   if (g == NULL)
581     caml_failwith ("test0rstringerr: used handle after closing it");
582
583   char *r;
584
585   caml_enter_blocking_section ();
586   r = guestfs_test0rstringerr (g);
587   caml_leave_blocking_section ();
588   if (r == NULL)
589     ocaml_guestfs_raise_error (g, "test0rstringerr");
590
591   rv = caml_copy_string (r);
592   free (r);
593   CAMLreturn (rv);
594 }
595
596 CAMLprim value
597 ocaml_guestfs_test0rstringlist (value gv, value valv)
598 {
599   CAMLparam2 (gv, valv);
600   CAMLlocal1 (rv);
601
602   guestfs_h *g = Guestfs_val (gv);
603   if (g == NULL)
604     caml_failwith ("test0rstringlist: used handle after closing it");
605
606   const char *val = String_val (valv);
607   int i;
608   char **r;
609
610   caml_enter_blocking_section ();
611   r = guestfs_test0rstringlist (g, val);
612   caml_leave_blocking_section ();
613   if (r == NULL)
614     ocaml_guestfs_raise_error (g, "test0rstringlist");
615
616   rv = caml_copy_string_array ((const char **) r);
617   for (i = 0; r[i] != NULL; ++i) free (r[i]);
618   free (r);
619   CAMLreturn (rv);
620 }
621
622 CAMLprim value
623 ocaml_guestfs_test0rstringlisterr (value gv)
624 {
625   CAMLparam1 (gv);
626   CAMLlocal1 (rv);
627
628   guestfs_h *g = Guestfs_val (gv);
629   if (g == NULL)
630     caml_failwith ("test0rstringlisterr: used handle after closing it");
631
632   int i;
633   char **r;
634
635   caml_enter_blocking_section ();
636   r = guestfs_test0rstringlisterr (g);
637   caml_leave_blocking_section ();
638   if (r == NULL)
639     ocaml_guestfs_raise_error (g, "test0rstringlisterr");
640
641   rv = caml_copy_string_array ((const char **) r);
642   for (i = 0; r[i] != NULL; ++i) free (r[i]);
643   free (r);
644   CAMLreturn (rv);
645 }
646
647 CAMLprim value
648 ocaml_guestfs_test0rintbool (value gv, value valv)
649 {
650   CAMLparam2 (gv, valv);
651   CAMLlocal1 (rv);
652
653   guestfs_h *g = Guestfs_val (gv);
654   if (g == NULL)
655     caml_failwith ("test0rintbool: used handle after closing it");
656
657   const char *val = String_val (valv);
658   struct guestfs_int_bool *r;
659
660   caml_enter_blocking_section ();
661   r = guestfs_test0rintbool (g, val);
662   caml_leave_blocking_section ();
663   if (r == NULL)
664     ocaml_guestfs_raise_error (g, "test0rintbool");
665
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);
670   CAMLreturn (rv);
671 }
672
673 CAMLprim value
674 ocaml_guestfs_test0rintboolerr (value gv)
675 {
676   CAMLparam1 (gv);
677   CAMLlocal1 (rv);
678
679   guestfs_h *g = Guestfs_val (gv);
680   if (g == NULL)
681     caml_failwith ("test0rintboolerr: used handle after closing it");
682
683   struct guestfs_int_bool *r;
684
685   caml_enter_blocking_section ();
686   r = guestfs_test0rintboolerr (g);
687   caml_leave_blocking_section ();
688   if (r == NULL)
689     ocaml_guestfs_raise_error (g, "test0rintboolerr");
690
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);
695   CAMLreturn (rv);
696 }
697
698 CAMLprim value
699 ocaml_guestfs_test0rpvlist (value gv, value valv)
700 {
701   CAMLparam2 (gv, valv);
702   CAMLlocal1 (rv);
703
704   guestfs_h *g = Guestfs_val (gv);
705   if (g == NULL)
706     caml_failwith ("test0rpvlist: used handle after closing it");
707
708   const char *val = String_val (valv);
709   struct guestfs_lvm_pv_list *r;
710
711   caml_enter_blocking_section ();
712   r = guestfs_test0rpvlist (g, val);
713   caml_leave_blocking_section ();
714   if (r == NULL)
715     ocaml_guestfs_raise_error (g, "test0rpvlist");
716
717   rv = copy_lvm_pv_list (r);
718   guestfs_free_lvm_pv_list (r);
719   CAMLreturn (rv);
720 }
721
722 CAMLprim value
723 ocaml_guestfs_test0rpvlisterr (value gv)
724 {
725   CAMLparam1 (gv);
726   CAMLlocal1 (rv);
727
728   guestfs_h *g = Guestfs_val (gv);
729   if (g == NULL)
730     caml_failwith ("test0rpvlisterr: used handle after closing it");
731
732   struct guestfs_lvm_pv_list *r;
733
734   caml_enter_blocking_section ();
735   r = guestfs_test0rpvlisterr (g);
736   caml_leave_blocking_section ();
737   if (r == NULL)
738     ocaml_guestfs_raise_error (g, "test0rpvlisterr");
739
740   rv = copy_lvm_pv_list (r);
741   guestfs_free_lvm_pv_list (r);
742   CAMLreturn (rv);
743 }
744
745 CAMLprim value
746 ocaml_guestfs_test0rvglist (value gv, value valv)
747 {
748   CAMLparam2 (gv, valv);
749   CAMLlocal1 (rv);
750
751   guestfs_h *g = Guestfs_val (gv);
752   if (g == NULL)
753     caml_failwith ("test0rvglist: used handle after closing it");
754
755   const char *val = String_val (valv);
756   struct guestfs_lvm_vg_list *r;
757
758   caml_enter_blocking_section ();
759   r = guestfs_test0rvglist (g, val);
760   caml_leave_blocking_section ();
761   if (r == NULL)
762     ocaml_guestfs_raise_error (g, "test0rvglist");
763
764   rv = copy_lvm_vg_list (r);
765   guestfs_free_lvm_vg_list (r);
766   CAMLreturn (rv);
767 }
768
769 CAMLprim value
770 ocaml_guestfs_test0rvglisterr (value gv)
771 {
772   CAMLparam1 (gv);
773   CAMLlocal1 (rv);
774
775   guestfs_h *g = Guestfs_val (gv);
776   if (g == NULL)
777     caml_failwith ("test0rvglisterr: used handle after closing it");
778
779   struct guestfs_lvm_vg_list *r;
780
781   caml_enter_blocking_section ();
782   r = guestfs_test0rvglisterr (g);
783   caml_leave_blocking_section ();
784   if (r == NULL)
785     ocaml_guestfs_raise_error (g, "test0rvglisterr");
786
787   rv = copy_lvm_vg_list (r);
788   guestfs_free_lvm_vg_list (r);
789   CAMLreturn (rv);
790 }
791
792 CAMLprim value
793 ocaml_guestfs_test0rlvlist (value gv, value valv)
794 {
795   CAMLparam2 (gv, valv);
796   CAMLlocal1 (rv);
797
798   guestfs_h *g = Guestfs_val (gv);
799   if (g == NULL)
800     caml_failwith ("test0rlvlist: used handle after closing it");
801
802   const char *val = String_val (valv);
803   struct guestfs_lvm_lv_list *r;
804
805   caml_enter_blocking_section ();
806   r = guestfs_test0rlvlist (g, val);
807   caml_leave_blocking_section ();
808   if (r == NULL)
809     ocaml_guestfs_raise_error (g, "test0rlvlist");
810
811   rv = copy_lvm_lv_list (r);
812   guestfs_free_lvm_lv_list (r);
813   CAMLreturn (rv);
814 }
815
816 CAMLprim value
817 ocaml_guestfs_test0rlvlisterr (value gv)
818 {
819   CAMLparam1 (gv);
820   CAMLlocal1 (rv);
821
822   guestfs_h *g = Guestfs_val (gv);
823   if (g == NULL)
824     caml_failwith ("test0rlvlisterr: used handle after closing it");
825
826   struct guestfs_lvm_lv_list *r;
827
828   caml_enter_blocking_section ();
829   r = guestfs_test0rlvlisterr (g);
830   caml_leave_blocking_section ();
831   if (r == NULL)
832     ocaml_guestfs_raise_error (g, "test0rlvlisterr");
833
834   rv = copy_lvm_lv_list (r);
835   guestfs_free_lvm_lv_list (r);
836   CAMLreturn (rv);
837 }
838
839 CAMLprim value
840 ocaml_guestfs_test0rstat (value gv, value valv)
841 {
842   CAMLparam2 (gv, valv);
843   CAMLlocal1 (rv);
844
845   guestfs_h *g = Guestfs_val (gv);
846   if (g == NULL)
847     caml_failwith ("test0rstat: used handle after closing it");
848
849   const char *val = String_val (valv);
850   struct guestfs_stat *r;
851
852   caml_enter_blocking_section ();
853   r = guestfs_test0rstat (g, val);
854   caml_leave_blocking_section ();
855   if (r == NULL)
856     ocaml_guestfs_raise_error (g, "test0rstat");
857
858   rv = copy_stat (r);
859   free (r);
860   CAMLreturn (rv);
861 }
862
863 CAMLprim value
864 ocaml_guestfs_test0rstaterr (value gv)
865 {
866   CAMLparam1 (gv);
867   CAMLlocal1 (rv);
868
869   guestfs_h *g = Guestfs_val (gv);
870   if (g == NULL)
871     caml_failwith ("test0rstaterr: used handle after closing it");
872
873   struct guestfs_stat *r;
874
875   caml_enter_blocking_section ();
876   r = guestfs_test0rstaterr (g);
877   caml_leave_blocking_section ();
878   if (r == NULL)
879     ocaml_guestfs_raise_error (g, "test0rstaterr");
880
881   rv = copy_stat (r);
882   free (r);
883   CAMLreturn (rv);
884 }
885
886 CAMLprim value
887 ocaml_guestfs_test0rstatvfs (value gv, value valv)
888 {
889   CAMLparam2 (gv, valv);
890   CAMLlocal1 (rv);
891
892   guestfs_h *g = Guestfs_val (gv);
893   if (g == NULL)
894     caml_failwith ("test0rstatvfs: used handle after closing it");
895
896   const char *val = String_val (valv);
897   struct guestfs_statvfs *r;
898
899   caml_enter_blocking_section ();
900   r = guestfs_test0rstatvfs (g, val);
901   caml_leave_blocking_section ();
902   if (r == NULL)
903     ocaml_guestfs_raise_error (g, "test0rstatvfs");
904
905   rv = copy_statvfs (r);
906   free (r);
907   CAMLreturn (rv);
908 }
909
910 CAMLprim value
911 ocaml_guestfs_test0rstatvfserr (value gv)
912 {
913   CAMLparam1 (gv);
914   CAMLlocal1 (rv);
915
916   guestfs_h *g = Guestfs_val (gv);
917   if (g == NULL)
918     caml_failwith ("test0rstatvfserr: used handle after closing it");
919
920   struct guestfs_statvfs *r;
921
922   caml_enter_blocking_section ();
923   r = guestfs_test0rstatvfserr (g);
924   caml_leave_blocking_section ();
925   if (r == NULL)
926     ocaml_guestfs_raise_error (g, "test0rstatvfserr");
927
928   rv = copy_statvfs (r);
929   free (r);
930   CAMLreturn (rv);
931 }
932
933 CAMLprim value
934 ocaml_guestfs_test0rhashtable (value gv, value valv)
935 {
936   CAMLparam2 (gv, valv);
937   CAMLlocal1 (rv);
938
939   guestfs_h *g = Guestfs_val (gv);
940   if (g == NULL)
941     caml_failwith ("test0rhashtable: used handle after closing it");
942
943   const char *val = String_val (valv);
944   int i;
945   char **r;
946
947   caml_enter_blocking_section ();
948   r = guestfs_test0rhashtable (g, val);
949   caml_leave_blocking_section ();
950   if (r == NULL)
951     ocaml_guestfs_raise_error (g, "test0rhashtable");
952
953   rv = copy_table (r);
954   for (i = 0; r[i] != NULL; ++i) free (r[i]);
955   free (r);
956   CAMLreturn (rv);
957 }
958
959 CAMLprim value
960 ocaml_guestfs_test0rhashtableerr (value gv)
961 {
962   CAMLparam1 (gv);
963   CAMLlocal1 (rv);
964
965   guestfs_h *g = Guestfs_val (gv);
966   if (g == NULL)
967     caml_failwith ("test0rhashtableerr: used handle after closing it");
968
969   int i;
970   char **r;
971
972   caml_enter_blocking_section ();
973   r = guestfs_test0rhashtableerr (g);
974   caml_leave_blocking_section ();
975   if (r == NULL)
976     ocaml_guestfs_raise_error (g, "test0rhashtableerr");
977
978   rv = copy_table (r);
979   for (i = 0; r[i] != NULL; ++i) free (r[i]);
980   free (r);
981   CAMLreturn (rv);
982 }
983
984 CAMLprim value
985 ocaml_guestfs_launch (value gv)
986 {
987   CAMLparam1 (gv);
988   CAMLlocal1 (rv);
989
990   guestfs_h *g = Guestfs_val (gv);
991   if (g == NULL)
992     caml_failwith ("launch: used handle after closing it");
993
994   int r;
995
996   caml_enter_blocking_section ();
997   r = guestfs_launch (g);
998   caml_leave_blocking_section ();
999   if (r == -1)
1000     ocaml_guestfs_raise_error (g, "launch");
1001
1002   rv = Val_unit;
1003   CAMLreturn (rv);
1004 }
1005
1006 CAMLprim value
1007 ocaml_guestfs_wait_ready (value gv)
1008 {
1009   CAMLparam1 (gv);
1010   CAMLlocal1 (rv);
1011
1012   guestfs_h *g = Guestfs_val (gv);
1013   if (g == NULL)
1014     caml_failwith ("wait_ready: used handle after closing it");
1015
1016   int r;
1017
1018   caml_enter_blocking_section ();
1019   r = guestfs_wait_ready (g);
1020   caml_leave_blocking_section ();
1021   if (r == -1)
1022     ocaml_guestfs_raise_error (g, "wait_ready");
1023
1024   rv = Val_unit;
1025   CAMLreturn (rv);
1026 }
1027
1028 CAMLprim value
1029 ocaml_guestfs_kill_subprocess (value gv)
1030 {
1031   CAMLparam1 (gv);
1032   CAMLlocal1 (rv);
1033
1034   guestfs_h *g = Guestfs_val (gv);
1035   if (g == NULL)
1036     caml_failwith ("kill_subprocess: used handle after closing it");
1037
1038   int r;
1039
1040   caml_enter_blocking_section ();
1041   r = guestfs_kill_subprocess (g);
1042   caml_leave_blocking_section ();
1043   if (r == -1)
1044     ocaml_guestfs_raise_error (g, "kill_subprocess");
1045
1046   rv = Val_unit;
1047   CAMLreturn (rv);
1048 }
1049
1050 CAMLprim value
1051 ocaml_guestfs_add_drive (value gv, value filenamev)
1052 {
1053   CAMLparam2 (gv, filenamev);
1054   CAMLlocal1 (rv);
1055
1056   guestfs_h *g = Guestfs_val (gv);
1057   if (g == NULL)
1058     caml_failwith ("add_drive: used handle after closing it");
1059
1060   const char *filename = String_val (filenamev);
1061   int r;
1062
1063   caml_enter_blocking_section ();
1064   r = guestfs_add_drive (g, filename);
1065   caml_leave_blocking_section ();
1066   if (r == -1)
1067     ocaml_guestfs_raise_error (g, "add_drive");
1068
1069   rv = Val_unit;
1070   CAMLreturn (rv);
1071 }
1072
1073 CAMLprim value
1074 ocaml_guestfs_add_cdrom (value gv, value filenamev)
1075 {
1076   CAMLparam2 (gv, filenamev);
1077   CAMLlocal1 (rv);
1078
1079   guestfs_h *g = Guestfs_val (gv);
1080   if (g == NULL)
1081     caml_failwith ("add_cdrom: used handle after closing it");
1082
1083   const char *filename = String_val (filenamev);
1084   int r;
1085
1086   caml_enter_blocking_section ();
1087   r = guestfs_add_cdrom (g, filename);
1088   caml_leave_blocking_section ();
1089   if (r == -1)
1090     ocaml_guestfs_raise_error (g, "add_cdrom");
1091
1092   rv = Val_unit;
1093   CAMLreturn (rv);
1094 }
1095
1096 CAMLprim value
1097 ocaml_guestfs_config (value gv, value qemuparamv, value qemuvaluev)
1098 {
1099   CAMLparam3 (gv, qemuparamv, qemuvaluev);
1100   CAMLlocal1 (rv);
1101
1102   guestfs_h *g = Guestfs_val (gv);
1103   if (g == NULL)
1104     caml_failwith ("config: used handle after closing it");
1105
1106   const char *qemuparam = String_val (qemuparamv);
1107   const char *qemuvalue =
1108     qemuvaluev != Val_int (0) ? String_val (Field (qemuvaluev, 0)) : NULL;
1109   int r;
1110
1111   caml_enter_blocking_section ();
1112   r = guestfs_config (g, qemuparam, qemuvalue);
1113   caml_leave_blocking_section ();
1114   if (r == -1)
1115     ocaml_guestfs_raise_error (g, "config");
1116
1117   rv = Val_unit;
1118   CAMLreturn (rv);
1119 }
1120
1121 CAMLprim value
1122 ocaml_guestfs_set_qemu (value gv, value qemuv)
1123 {
1124   CAMLparam2 (gv, qemuv);
1125   CAMLlocal1 (rv);
1126
1127   guestfs_h *g = Guestfs_val (gv);
1128   if (g == NULL)
1129     caml_failwith ("set_qemu: used handle after closing it");
1130
1131   const char *qemu = String_val (qemuv);
1132   int r;
1133
1134   caml_enter_blocking_section ();
1135   r = guestfs_set_qemu (g, qemu);
1136   caml_leave_blocking_section ();
1137   if (r == -1)
1138     ocaml_guestfs_raise_error (g, "set_qemu");
1139
1140   rv = Val_unit;
1141   CAMLreturn (rv);
1142 }
1143
1144 CAMLprim value
1145 ocaml_guestfs_get_qemu (value gv)
1146 {
1147   CAMLparam1 (gv);
1148   CAMLlocal1 (rv);
1149
1150   guestfs_h *g = Guestfs_val (gv);
1151   if (g == NULL)
1152     caml_failwith ("get_qemu: used handle after closing it");
1153
1154   const char *r;
1155
1156   caml_enter_blocking_section ();
1157   r = guestfs_get_qemu (g);
1158   caml_leave_blocking_section ();
1159   if (r == NULL)
1160     ocaml_guestfs_raise_error (g, "get_qemu");
1161
1162   rv = caml_copy_string (r);
1163   CAMLreturn (rv);
1164 }
1165
1166 CAMLprim value
1167 ocaml_guestfs_set_path (value gv, value pathv)
1168 {
1169   CAMLparam2 (gv, pathv);
1170   CAMLlocal1 (rv);
1171
1172   guestfs_h *g = Guestfs_val (gv);
1173   if (g == NULL)
1174     caml_failwith ("set_path: used handle after closing it");
1175
1176   const char *path = String_val (pathv);
1177   int r;
1178
1179   caml_enter_blocking_section ();
1180   r = guestfs_set_path (g, path);
1181   caml_leave_blocking_section ();
1182   if (r == -1)
1183     ocaml_guestfs_raise_error (g, "set_path");
1184
1185   rv = Val_unit;
1186   CAMLreturn (rv);
1187 }
1188
1189 CAMLprim value
1190 ocaml_guestfs_get_path (value gv)
1191 {
1192   CAMLparam1 (gv);
1193   CAMLlocal1 (rv);
1194
1195   guestfs_h *g = Guestfs_val (gv);
1196   if (g == NULL)
1197     caml_failwith ("get_path: used handle after closing it");
1198
1199   const char *r;
1200
1201   caml_enter_blocking_section ();
1202   r = guestfs_get_path (g);
1203   caml_leave_blocking_section ();
1204   if (r == NULL)
1205     ocaml_guestfs_raise_error (g, "get_path");
1206
1207   rv = caml_copy_string (r);
1208   CAMLreturn (rv);
1209 }
1210
1211 CAMLprim value
1212 ocaml_guestfs_set_append (value gv, value appendv)
1213 {
1214   CAMLparam2 (gv, appendv);
1215   CAMLlocal1 (rv);
1216
1217   guestfs_h *g = Guestfs_val (gv);
1218   if (g == NULL)
1219     caml_failwith ("set_append: used handle after closing it");
1220
1221   const char *append = String_val (appendv);
1222   int r;
1223
1224   caml_enter_blocking_section ();
1225   r = guestfs_set_append (g, append);
1226   caml_leave_blocking_section ();
1227   if (r == -1)
1228     ocaml_guestfs_raise_error (g, "set_append");
1229
1230   rv = Val_unit;
1231   CAMLreturn (rv);
1232 }
1233
1234 CAMLprim value
1235 ocaml_guestfs_get_append (value gv)
1236 {
1237   CAMLparam1 (gv);
1238   CAMLlocal1 (rv);
1239
1240   guestfs_h *g = Guestfs_val (gv);
1241   if (g == NULL)
1242     caml_failwith ("get_append: used handle after closing it");
1243
1244   const char *r;
1245
1246   caml_enter_blocking_section ();
1247   r = guestfs_get_append (g);
1248   caml_leave_blocking_section ();
1249   if (r == NULL)
1250     ocaml_guestfs_raise_error (g, "get_append");
1251
1252   rv = caml_copy_string (r);
1253   CAMLreturn (rv);
1254 }
1255
1256 CAMLprim value
1257 ocaml_guestfs_set_autosync (value gv, value autosyncv)
1258 {
1259   CAMLparam2 (gv, autosyncv);
1260   CAMLlocal1 (rv);
1261
1262   guestfs_h *g = Guestfs_val (gv);
1263   if (g == NULL)
1264     caml_failwith ("set_autosync: used handle after closing it");
1265
1266   int autosync = Bool_val (autosyncv);
1267   int r;
1268
1269   caml_enter_blocking_section ();
1270   r = guestfs_set_autosync (g, autosync);
1271   caml_leave_blocking_section ();
1272   if (r == -1)
1273     ocaml_guestfs_raise_error (g, "set_autosync");
1274
1275   rv = Val_unit;
1276   CAMLreturn (rv);
1277 }
1278
1279 CAMLprim value
1280 ocaml_guestfs_get_autosync (value gv)
1281 {
1282   CAMLparam1 (gv);
1283   CAMLlocal1 (rv);
1284
1285   guestfs_h *g = Guestfs_val (gv);
1286   if (g == NULL)
1287     caml_failwith ("get_autosync: used handle after closing it");
1288
1289   int r;
1290
1291   caml_enter_blocking_section ();
1292   r = guestfs_get_autosync (g);
1293   caml_leave_blocking_section ();
1294   if (r == -1)
1295     ocaml_guestfs_raise_error (g, "get_autosync");
1296
1297   rv = Val_bool (r);
1298   CAMLreturn (rv);
1299 }
1300
1301 CAMLprim value
1302 ocaml_guestfs_set_verbose (value gv, value verbosev)
1303 {
1304   CAMLparam2 (gv, verbosev);
1305   CAMLlocal1 (rv);
1306
1307   guestfs_h *g = Guestfs_val (gv);
1308   if (g == NULL)
1309     caml_failwith ("set_verbose: used handle after closing it");
1310
1311   int verbose = Bool_val (verbosev);
1312   int r;
1313
1314   caml_enter_blocking_section ();
1315   r = guestfs_set_verbose (g, verbose);
1316   caml_leave_blocking_section ();
1317   if (r == -1)
1318     ocaml_guestfs_raise_error (g, "set_verbose");
1319
1320   rv = Val_unit;
1321   CAMLreturn (rv);
1322 }
1323
1324 CAMLprim value
1325 ocaml_guestfs_get_verbose (value gv)
1326 {
1327   CAMLparam1 (gv);
1328   CAMLlocal1 (rv);
1329
1330   guestfs_h *g = Guestfs_val (gv);
1331   if (g == NULL)
1332     caml_failwith ("get_verbose: used handle after closing it");
1333
1334   int r;
1335
1336   caml_enter_blocking_section ();
1337   r = guestfs_get_verbose (g);
1338   caml_leave_blocking_section ();
1339   if (r == -1)
1340     ocaml_guestfs_raise_error (g, "get_verbose");
1341
1342   rv = Val_bool (r);
1343   CAMLreturn (rv);
1344 }
1345
1346 CAMLprim value
1347 ocaml_guestfs_is_ready (value gv)
1348 {
1349   CAMLparam1 (gv);
1350   CAMLlocal1 (rv);
1351
1352   guestfs_h *g = Guestfs_val (gv);
1353   if (g == NULL)
1354     caml_failwith ("is_ready: used handle after closing it");
1355
1356   int r;
1357
1358   caml_enter_blocking_section ();
1359   r = guestfs_is_ready (g);
1360   caml_leave_blocking_section ();
1361   if (r == -1)
1362     ocaml_guestfs_raise_error (g, "is_ready");
1363
1364   rv = Val_bool (r);
1365   CAMLreturn (rv);
1366 }
1367
1368 CAMLprim value
1369 ocaml_guestfs_is_config (value gv)
1370 {
1371   CAMLparam1 (gv);
1372   CAMLlocal1 (rv);
1373
1374   guestfs_h *g = Guestfs_val (gv);
1375   if (g == NULL)
1376     caml_failwith ("is_config: used handle after closing it");
1377
1378   int r;
1379
1380   caml_enter_blocking_section ();
1381   r = guestfs_is_config (g);
1382   caml_leave_blocking_section ();
1383   if (r == -1)
1384     ocaml_guestfs_raise_error (g, "is_config");
1385
1386   rv = Val_bool (r);
1387   CAMLreturn (rv);
1388 }
1389
1390 CAMLprim value
1391 ocaml_guestfs_is_launching (value gv)
1392 {
1393   CAMLparam1 (gv);
1394   CAMLlocal1 (rv);
1395
1396   guestfs_h *g = Guestfs_val (gv);
1397   if (g == NULL)
1398     caml_failwith ("is_launching: used handle after closing it");
1399
1400   int r;
1401
1402   caml_enter_blocking_section ();
1403   r = guestfs_is_launching (g);
1404   caml_leave_blocking_section ();
1405   if (r == -1)
1406     ocaml_guestfs_raise_error (g, "is_launching");
1407
1408   rv = Val_bool (r);
1409   CAMLreturn (rv);
1410 }
1411
1412 CAMLprim value
1413 ocaml_guestfs_is_busy (value gv)
1414 {
1415   CAMLparam1 (gv);
1416   CAMLlocal1 (rv);
1417
1418   guestfs_h *g = Guestfs_val (gv);
1419   if (g == NULL)
1420     caml_failwith ("is_busy: used handle after closing it");
1421
1422   int r;
1423
1424   caml_enter_blocking_section ();
1425   r = guestfs_is_busy (g);
1426   caml_leave_blocking_section ();
1427   if (r == -1)
1428     ocaml_guestfs_raise_error (g, "is_busy");
1429
1430   rv = Val_bool (r);
1431   CAMLreturn (rv);
1432 }
1433
1434 CAMLprim value
1435 ocaml_guestfs_get_state (value gv)
1436 {
1437   CAMLparam1 (gv);
1438   CAMLlocal1 (rv);
1439
1440   guestfs_h *g = Guestfs_val (gv);
1441   if (g == NULL)
1442     caml_failwith ("get_state: used handle after closing it");
1443
1444   int r;
1445
1446   caml_enter_blocking_section ();
1447   r = guestfs_get_state (g);
1448   caml_leave_blocking_section ();
1449   if (r == -1)
1450     ocaml_guestfs_raise_error (g, "get_state");
1451
1452   rv = Val_int (r);
1453   CAMLreturn (rv);
1454 }
1455
1456 CAMLprim value
1457 ocaml_guestfs_set_busy (value gv)
1458 {
1459   CAMLparam1 (gv);
1460   CAMLlocal1 (rv);
1461
1462   guestfs_h *g = Guestfs_val (gv);
1463   if (g == NULL)
1464     caml_failwith ("set_busy: used handle after closing it");
1465
1466   int r;
1467
1468   caml_enter_blocking_section ();
1469   r = guestfs_set_busy (g);
1470   caml_leave_blocking_section ();
1471   if (r == -1)
1472     ocaml_guestfs_raise_error (g, "set_busy");
1473
1474   rv = Val_unit;
1475   CAMLreturn (rv);
1476 }
1477
1478 CAMLprim value
1479 ocaml_guestfs_set_ready (value gv)
1480 {
1481   CAMLparam1 (gv);
1482   CAMLlocal1 (rv);
1483
1484   guestfs_h *g = Guestfs_val (gv);
1485   if (g == NULL)
1486     caml_failwith ("set_ready: used handle after closing it");
1487
1488   int r;
1489
1490   caml_enter_blocking_section ();
1491   r = guestfs_set_ready (g);
1492   caml_leave_blocking_section ();
1493   if (r == -1)
1494     ocaml_guestfs_raise_error (g, "set_ready");
1495
1496   rv = Val_unit;
1497   CAMLreturn (rv);
1498 }
1499
1500 CAMLprim value
1501 ocaml_guestfs_end_busy (value gv)
1502 {
1503   CAMLparam1 (gv);
1504   CAMLlocal1 (rv);
1505
1506   guestfs_h *g = Guestfs_val (gv);
1507   if (g == NULL)
1508     caml_failwith ("end_busy: used handle after closing it");
1509
1510   int r;
1511
1512   caml_enter_blocking_section ();
1513   r = guestfs_end_busy (g);
1514   caml_leave_blocking_section ();
1515   if (r == -1)
1516     ocaml_guestfs_raise_error (g, "end_busy");
1517
1518   rv = Val_unit;
1519   CAMLreturn (rv);
1520 }
1521
1522 CAMLprim value
1523 ocaml_guestfs_mount (value gv, value devicev, value mountpointv)
1524 {
1525   CAMLparam3 (gv, devicev, mountpointv);
1526   CAMLlocal1 (rv);
1527
1528   guestfs_h *g = Guestfs_val (gv);
1529   if (g == NULL)
1530     caml_failwith ("mount: used handle after closing it");
1531
1532   const char *device = String_val (devicev);
1533   const char *mountpoint = String_val (mountpointv);
1534   int r;
1535
1536   caml_enter_blocking_section ();
1537   r = guestfs_mount (g, device, mountpoint);
1538   caml_leave_blocking_section ();
1539   if (r == -1)
1540     ocaml_guestfs_raise_error (g, "mount");
1541
1542   rv = Val_unit;
1543   CAMLreturn (rv);
1544 }
1545
1546 CAMLprim value
1547 ocaml_guestfs_sync (value gv)
1548 {
1549   CAMLparam1 (gv);
1550   CAMLlocal1 (rv);
1551
1552   guestfs_h *g = Guestfs_val (gv);
1553   if (g == NULL)
1554     caml_failwith ("sync: used handle after closing it");
1555
1556   int r;
1557
1558   caml_enter_blocking_section ();
1559   r = guestfs_sync (g);
1560   caml_leave_blocking_section ();
1561   if (r == -1)
1562     ocaml_guestfs_raise_error (g, "sync");
1563
1564   rv = Val_unit;
1565   CAMLreturn (rv);
1566 }
1567
1568 CAMLprim value
1569 ocaml_guestfs_touch (value gv, value pathv)
1570 {
1571   CAMLparam2 (gv, pathv);
1572   CAMLlocal1 (rv);
1573
1574   guestfs_h *g = Guestfs_val (gv);
1575   if (g == NULL)
1576     caml_failwith ("touch: used handle after closing it");
1577
1578   const char *path = String_val (pathv);
1579   int r;
1580
1581   caml_enter_blocking_section ();
1582   r = guestfs_touch (g, path);
1583   caml_leave_blocking_section ();
1584   if (r == -1)
1585     ocaml_guestfs_raise_error (g, "touch");
1586
1587   rv = Val_unit;
1588   CAMLreturn (rv);
1589 }
1590
1591 CAMLprim value
1592 ocaml_guestfs_cat (value gv, value pathv)
1593 {
1594   CAMLparam2 (gv, pathv);
1595   CAMLlocal1 (rv);
1596
1597   guestfs_h *g = Guestfs_val (gv);
1598   if (g == NULL)
1599     caml_failwith ("cat: used handle after closing it");
1600
1601   const char *path = String_val (pathv);
1602   char *r;
1603
1604   caml_enter_blocking_section ();
1605   r = guestfs_cat (g, path);
1606   caml_leave_blocking_section ();
1607   if (r == NULL)
1608     ocaml_guestfs_raise_error (g, "cat");
1609
1610   rv = caml_copy_string (r);
1611   free (r);
1612   CAMLreturn (rv);
1613 }
1614
1615 CAMLprim value
1616 ocaml_guestfs_ll (value gv, value directoryv)
1617 {
1618   CAMLparam2 (gv, directoryv);
1619   CAMLlocal1 (rv);
1620
1621   guestfs_h *g = Guestfs_val (gv);
1622   if (g == NULL)
1623     caml_failwith ("ll: used handle after closing it");
1624
1625   const char *directory = String_val (directoryv);
1626   char *r;
1627
1628   caml_enter_blocking_section ();
1629   r = guestfs_ll (g, directory);
1630   caml_leave_blocking_section ();
1631   if (r == NULL)
1632     ocaml_guestfs_raise_error (g, "ll");
1633
1634   rv = caml_copy_string (r);
1635   free (r);
1636   CAMLreturn (rv);
1637 }
1638
1639 CAMLprim value
1640 ocaml_guestfs_ls (value gv, value directoryv)
1641 {
1642   CAMLparam2 (gv, directoryv);
1643   CAMLlocal1 (rv);
1644
1645   guestfs_h *g = Guestfs_val (gv);
1646   if (g == NULL)
1647     caml_failwith ("ls: used handle after closing it");
1648
1649   const char *directory = String_val (directoryv);
1650   int i;
1651   char **r;
1652
1653   caml_enter_blocking_section ();
1654   r = guestfs_ls (g, directory);
1655   caml_leave_blocking_section ();
1656   if (r == NULL)
1657     ocaml_guestfs_raise_error (g, "ls");
1658
1659   rv = caml_copy_string_array ((const char **) r);
1660   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1661   free (r);
1662   CAMLreturn (rv);
1663 }
1664
1665 CAMLprim value
1666 ocaml_guestfs_list_devices (value gv)
1667 {
1668   CAMLparam1 (gv);
1669   CAMLlocal1 (rv);
1670
1671   guestfs_h *g = Guestfs_val (gv);
1672   if (g == NULL)
1673     caml_failwith ("list_devices: used handle after closing it");
1674
1675   int i;
1676   char **r;
1677
1678   caml_enter_blocking_section ();
1679   r = guestfs_list_devices (g);
1680   caml_leave_blocking_section ();
1681   if (r == NULL)
1682     ocaml_guestfs_raise_error (g, "list_devices");
1683
1684   rv = caml_copy_string_array ((const char **) r);
1685   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1686   free (r);
1687   CAMLreturn (rv);
1688 }
1689
1690 CAMLprim value
1691 ocaml_guestfs_list_partitions (value gv)
1692 {
1693   CAMLparam1 (gv);
1694   CAMLlocal1 (rv);
1695
1696   guestfs_h *g = Guestfs_val (gv);
1697   if (g == NULL)
1698     caml_failwith ("list_partitions: used handle after closing it");
1699
1700   int i;
1701   char **r;
1702
1703   caml_enter_blocking_section ();
1704   r = guestfs_list_partitions (g);
1705   caml_leave_blocking_section ();
1706   if (r == NULL)
1707     ocaml_guestfs_raise_error (g, "list_partitions");
1708
1709   rv = caml_copy_string_array ((const char **) r);
1710   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1711   free (r);
1712   CAMLreturn (rv);
1713 }
1714
1715 CAMLprim value
1716 ocaml_guestfs_pvs (value gv)
1717 {
1718   CAMLparam1 (gv);
1719   CAMLlocal1 (rv);
1720
1721   guestfs_h *g = Guestfs_val (gv);
1722   if (g == NULL)
1723     caml_failwith ("pvs: used handle after closing it");
1724
1725   int i;
1726   char **r;
1727
1728   caml_enter_blocking_section ();
1729   r = guestfs_pvs (g);
1730   caml_leave_blocking_section ();
1731   if (r == NULL)
1732     ocaml_guestfs_raise_error (g, "pvs");
1733
1734   rv = caml_copy_string_array ((const char **) r);
1735   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1736   free (r);
1737   CAMLreturn (rv);
1738 }
1739
1740 CAMLprim value
1741 ocaml_guestfs_vgs (value gv)
1742 {
1743   CAMLparam1 (gv);
1744   CAMLlocal1 (rv);
1745
1746   guestfs_h *g = Guestfs_val (gv);
1747   if (g == NULL)
1748     caml_failwith ("vgs: used handle after closing it");
1749
1750   int i;
1751   char **r;
1752
1753   caml_enter_blocking_section ();
1754   r = guestfs_vgs (g);
1755   caml_leave_blocking_section ();
1756   if (r == NULL)
1757     ocaml_guestfs_raise_error (g, "vgs");
1758
1759   rv = caml_copy_string_array ((const char **) r);
1760   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1761   free (r);
1762   CAMLreturn (rv);
1763 }
1764
1765 CAMLprim value
1766 ocaml_guestfs_lvs (value gv)
1767 {
1768   CAMLparam1 (gv);
1769   CAMLlocal1 (rv);
1770
1771   guestfs_h *g = Guestfs_val (gv);
1772   if (g == NULL)
1773     caml_failwith ("lvs: used handle after closing it");
1774
1775   int i;
1776   char **r;
1777
1778   caml_enter_blocking_section ();
1779   r = guestfs_lvs (g);
1780   caml_leave_blocking_section ();
1781   if (r == NULL)
1782     ocaml_guestfs_raise_error (g, "lvs");
1783
1784   rv = caml_copy_string_array ((const char **) r);
1785   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1786   free (r);
1787   CAMLreturn (rv);
1788 }
1789
1790 CAMLprim value
1791 ocaml_guestfs_pvs_full (value gv)
1792 {
1793   CAMLparam1 (gv);
1794   CAMLlocal1 (rv);
1795
1796   guestfs_h *g = Guestfs_val (gv);
1797   if (g == NULL)
1798     caml_failwith ("pvs_full: used handle after closing it");
1799
1800   struct guestfs_lvm_pv_list *r;
1801
1802   caml_enter_blocking_section ();
1803   r = guestfs_pvs_full (g);
1804   caml_leave_blocking_section ();
1805   if (r == NULL)
1806     ocaml_guestfs_raise_error (g, "pvs_full");
1807
1808   rv = copy_lvm_pv_list (r);
1809   guestfs_free_lvm_pv_list (r);
1810   CAMLreturn (rv);
1811 }
1812
1813 CAMLprim value
1814 ocaml_guestfs_vgs_full (value gv)
1815 {
1816   CAMLparam1 (gv);
1817   CAMLlocal1 (rv);
1818
1819   guestfs_h *g = Guestfs_val (gv);
1820   if (g == NULL)
1821     caml_failwith ("vgs_full: used handle after closing it");
1822
1823   struct guestfs_lvm_vg_list *r;
1824
1825   caml_enter_blocking_section ();
1826   r = guestfs_vgs_full (g);
1827   caml_leave_blocking_section ();
1828   if (r == NULL)
1829     ocaml_guestfs_raise_error (g, "vgs_full");
1830
1831   rv = copy_lvm_vg_list (r);
1832   guestfs_free_lvm_vg_list (r);
1833   CAMLreturn (rv);
1834 }
1835
1836 CAMLprim value
1837 ocaml_guestfs_lvs_full (value gv)
1838 {
1839   CAMLparam1 (gv);
1840   CAMLlocal1 (rv);
1841
1842   guestfs_h *g = Guestfs_val (gv);
1843   if (g == NULL)
1844     caml_failwith ("lvs_full: used handle after closing it");
1845
1846   struct guestfs_lvm_lv_list *r;
1847
1848   caml_enter_blocking_section ();
1849   r = guestfs_lvs_full (g);
1850   caml_leave_blocking_section ();
1851   if (r == NULL)
1852     ocaml_guestfs_raise_error (g, "lvs_full");
1853
1854   rv = copy_lvm_lv_list (r);
1855   guestfs_free_lvm_lv_list (r);
1856   CAMLreturn (rv);
1857 }
1858
1859 CAMLprim value
1860 ocaml_guestfs_read_lines (value gv, value pathv)
1861 {
1862   CAMLparam2 (gv, pathv);
1863   CAMLlocal1 (rv);
1864
1865   guestfs_h *g = Guestfs_val (gv);
1866   if (g == NULL)
1867     caml_failwith ("read_lines: used handle after closing it");
1868
1869   const char *path = String_val (pathv);
1870   int i;
1871   char **r;
1872
1873   caml_enter_blocking_section ();
1874   r = guestfs_read_lines (g, path);
1875   caml_leave_blocking_section ();
1876   if (r == NULL)
1877     ocaml_guestfs_raise_error (g, "read_lines");
1878
1879   rv = caml_copy_string_array ((const char **) r);
1880   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1881   free (r);
1882   CAMLreturn (rv);
1883 }
1884
1885 CAMLprim value
1886 ocaml_guestfs_aug_init (value gv, value rootv, value flagsv)
1887 {
1888   CAMLparam3 (gv, rootv, flagsv);
1889   CAMLlocal1 (rv);
1890
1891   guestfs_h *g = Guestfs_val (gv);
1892   if (g == NULL)
1893     caml_failwith ("aug_init: used handle after closing it");
1894
1895   const char *root = String_val (rootv);
1896   int flags = Int_val (flagsv);
1897   int r;
1898
1899   caml_enter_blocking_section ();
1900   r = guestfs_aug_init (g, root, flags);
1901   caml_leave_blocking_section ();
1902   if (r == -1)
1903     ocaml_guestfs_raise_error (g, "aug_init");
1904
1905   rv = Val_unit;
1906   CAMLreturn (rv);
1907 }
1908
1909 CAMLprim value
1910 ocaml_guestfs_aug_close (value gv)
1911 {
1912   CAMLparam1 (gv);
1913   CAMLlocal1 (rv);
1914
1915   guestfs_h *g = Guestfs_val (gv);
1916   if (g == NULL)
1917     caml_failwith ("aug_close: used handle after closing it");
1918
1919   int r;
1920
1921   caml_enter_blocking_section ();
1922   r = guestfs_aug_close (g);
1923   caml_leave_blocking_section ();
1924   if (r == -1)
1925     ocaml_guestfs_raise_error (g, "aug_close");
1926
1927   rv = Val_unit;
1928   CAMLreturn (rv);
1929 }
1930
1931 CAMLprim value
1932 ocaml_guestfs_aug_defvar (value gv, value namev, value exprv)
1933 {
1934   CAMLparam3 (gv, namev, exprv);
1935   CAMLlocal1 (rv);
1936
1937   guestfs_h *g = Guestfs_val (gv);
1938   if (g == NULL)
1939     caml_failwith ("aug_defvar: used handle after closing it");
1940
1941   const char *name = String_val (namev);
1942   const char *expr =
1943     exprv != Val_int (0) ? String_val (Field (exprv, 0)) : NULL;
1944   int r;
1945
1946   caml_enter_blocking_section ();
1947   r = guestfs_aug_defvar (g, name, expr);
1948   caml_leave_blocking_section ();
1949   if (r == -1)
1950     ocaml_guestfs_raise_error (g, "aug_defvar");
1951
1952   rv = Val_int (r);
1953   CAMLreturn (rv);
1954 }
1955
1956 CAMLprim value
1957 ocaml_guestfs_aug_defnode (value gv, value namev, value exprv, value valv)
1958 {
1959   CAMLparam4 (gv, namev, exprv, valv);
1960   CAMLlocal1 (rv);
1961
1962   guestfs_h *g = Guestfs_val (gv);
1963   if (g == NULL)
1964     caml_failwith ("aug_defnode: used handle after closing it");
1965
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;
1970
1971   caml_enter_blocking_section ();
1972   r = guestfs_aug_defnode (g, name, expr, val);
1973   caml_leave_blocking_section ();
1974   if (r == NULL)
1975     ocaml_guestfs_raise_error (g, "aug_defnode");
1976
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);
1981   CAMLreturn (rv);
1982 }
1983
1984 CAMLprim value
1985 ocaml_guestfs_aug_get (value gv, value pathv)
1986 {
1987   CAMLparam2 (gv, pathv);
1988   CAMLlocal1 (rv);
1989
1990   guestfs_h *g = Guestfs_val (gv);
1991   if (g == NULL)
1992     caml_failwith ("aug_get: used handle after closing it");
1993
1994   const char *path = String_val (pathv);
1995   char *r;
1996
1997   caml_enter_blocking_section ();
1998   r = guestfs_aug_get (g, path);
1999   caml_leave_blocking_section ();
2000   if (r == NULL)
2001     ocaml_guestfs_raise_error (g, "aug_get");
2002
2003   rv = caml_copy_string (r);
2004   free (r);
2005   CAMLreturn (rv);
2006 }
2007
2008 CAMLprim value
2009 ocaml_guestfs_aug_set (value gv, value pathv, value valv)
2010 {
2011   CAMLparam3 (gv, pathv, valv);
2012   CAMLlocal1 (rv);
2013
2014   guestfs_h *g = Guestfs_val (gv);
2015   if (g == NULL)
2016     caml_failwith ("aug_set: used handle after closing it");
2017
2018   const char *path = String_val (pathv);
2019   const char *val = String_val (valv);
2020   int r;
2021
2022   caml_enter_blocking_section ();
2023   r = guestfs_aug_set (g, path, val);
2024   caml_leave_blocking_section ();
2025   if (r == -1)
2026     ocaml_guestfs_raise_error (g, "aug_set");
2027
2028   rv = Val_unit;
2029   CAMLreturn (rv);
2030 }
2031
2032 CAMLprim value
2033 ocaml_guestfs_aug_insert (value gv, value pathv, value labelv, value beforev)
2034 {
2035   CAMLparam4 (gv, pathv, labelv, beforev);
2036   CAMLlocal1 (rv);
2037
2038   guestfs_h *g = Guestfs_val (gv);
2039   if (g == NULL)
2040     caml_failwith ("aug_insert: used handle after closing it");
2041
2042   const char *path = String_val (pathv);
2043   const char *label = String_val (labelv);
2044   int before = Bool_val (beforev);
2045   int r;
2046
2047   caml_enter_blocking_section ();
2048   r = guestfs_aug_insert (g, path, label, before);
2049   caml_leave_blocking_section ();
2050   if (r == -1)
2051     ocaml_guestfs_raise_error (g, "aug_insert");
2052
2053   rv = Val_unit;
2054   CAMLreturn (rv);
2055 }
2056
2057 CAMLprim value
2058 ocaml_guestfs_aug_rm (value gv, value pathv)
2059 {
2060   CAMLparam2 (gv, pathv);
2061   CAMLlocal1 (rv);
2062
2063   guestfs_h *g = Guestfs_val (gv);
2064   if (g == NULL)
2065     caml_failwith ("aug_rm: used handle after closing it");
2066
2067   const char *path = String_val (pathv);
2068   int r;
2069
2070   caml_enter_blocking_section ();
2071   r = guestfs_aug_rm (g, path);
2072   caml_leave_blocking_section ();
2073   if (r == -1)
2074     ocaml_guestfs_raise_error (g, "aug_rm");
2075
2076   rv = Val_int (r);
2077   CAMLreturn (rv);
2078 }
2079
2080 CAMLprim value
2081 ocaml_guestfs_aug_mv (value gv, value srcv, value destv)
2082 {
2083   CAMLparam3 (gv, srcv, destv);
2084   CAMLlocal1 (rv);
2085
2086   guestfs_h *g = Guestfs_val (gv);
2087   if (g == NULL)
2088     caml_failwith ("aug_mv: used handle after closing it");
2089
2090   const char *src = String_val (srcv);
2091   const char *dest = String_val (destv);
2092   int r;
2093
2094   caml_enter_blocking_section ();
2095   r = guestfs_aug_mv (g, src, dest);
2096   caml_leave_blocking_section ();
2097   if (r == -1)
2098     ocaml_guestfs_raise_error (g, "aug_mv");
2099
2100   rv = Val_unit;
2101   CAMLreturn (rv);
2102 }
2103
2104 CAMLprim value
2105 ocaml_guestfs_aug_match (value gv, value pathv)
2106 {
2107   CAMLparam2 (gv, pathv);
2108   CAMLlocal1 (rv);
2109
2110   guestfs_h *g = Guestfs_val (gv);
2111   if (g == NULL)
2112     caml_failwith ("aug_match: used handle after closing it");
2113
2114   const char *path = String_val (pathv);
2115   int i;
2116   char **r;
2117
2118   caml_enter_blocking_section ();
2119   r = guestfs_aug_match (g, path);
2120   caml_leave_blocking_section ();
2121   if (r == NULL)
2122     ocaml_guestfs_raise_error (g, "aug_match");
2123
2124   rv = caml_copy_string_array ((const char **) r);
2125   for (i = 0; r[i] != NULL; ++i) free (r[i]);
2126   free (r);
2127   CAMLreturn (rv);
2128 }
2129
2130 CAMLprim value
2131 ocaml_guestfs_aug_save (value gv)
2132 {
2133   CAMLparam1 (gv);
2134   CAMLlocal1 (rv);
2135
2136   guestfs_h *g = Guestfs_val (gv);
2137   if (g == NULL)
2138     caml_failwith ("aug_save: used handle after closing it");
2139
2140   int r;
2141
2142   caml_enter_blocking_section ();
2143   r = guestfs_aug_save (g);
2144   caml_leave_blocking_section ();
2145   if (r == -1)
2146     ocaml_guestfs_raise_error (g, "aug_save");
2147
2148   rv = Val_unit;
2149   CAMLreturn (rv);
2150 }
2151
2152 CAMLprim value
2153 ocaml_guestfs_aug_load (value gv)
2154 {
2155   CAMLparam1 (gv);
2156   CAMLlocal1 (rv);
2157
2158   guestfs_h *g = Guestfs_val (gv);
2159   if (g == NULL)
2160     caml_failwith ("aug_load: used handle after closing it");
2161
2162   int r;
2163
2164   caml_enter_blocking_section ();
2165   r = guestfs_aug_load (g);
2166   caml_leave_blocking_section ();
2167   if (r == -1)
2168     ocaml_guestfs_raise_error (g, "aug_load");
2169
2170   rv = Val_unit;
2171   CAMLreturn (rv);
2172 }
2173
2174 CAMLprim value
2175 ocaml_guestfs_aug_ls (value gv, value pathv)
2176 {
2177   CAMLparam2 (gv, pathv);
2178   CAMLlocal1 (rv);
2179
2180   guestfs_h *g = Guestfs_val (gv);
2181   if (g == NULL)
2182     caml_failwith ("aug_ls: used handle after closing it");
2183
2184   const char *path = String_val (pathv);
2185   int i;
2186   char **r;
2187
2188   caml_enter_blocking_section ();
2189   r = guestfs_aug_ls (g, path);
2190   caml_leave_blocking_section ();
2191   if (r == NULL)
2192     ocaml_guestfs_raise_error (g, "aug_ls");
2193
2194   rv = caml_copy_string_array ((const char **) r);
2195   for (i = 0; r[i] != NULL; ++i) free (r[i]);
2196   free (r);
2197   CAMLreturn (rv);
2198 }
2199
2200 CAMLprim value
2201 ocaml_guestfs_rm (value gv, value pathv)
2202 {
2203   CAMLparam2 (gv, pathv);
2204   CAMLlocal1 (rv);
2205
2206   guestfs_h *g = Guestfs_val (gv);
2207   if (g == NULL)
2208     caml_failwith ("rm: used handle after closing it");
2209
2210   const char *path = String_val (pathv);
2211   int r;
2212
2213   caml_enter_blocking_section ();
2214   r = guestfs_rm (g, path);
2215   caml_leave_blocking_section ();
2216   if (r == -1)
2217     ocaml_guestfs_raise_error (g, "rm");
2218
2219   rv = Val_unit;
2220   CAMLreturn (rv);
2221 }
2222
2223 CAMLprim value
2224 ocaml_guestfs_rmdir (value gv, value pathv)
2225 {
2226   CAMLparam2 (gv, pathv);
2227   CAMLlocal1 (rv);
2228
2229   guestfs_h *g = Guestfs_val (gv);
2230   if (g == NULL)
2231     caml_failwith ("rmdir: used handle after closing it");
2232
2233   const char *path = String_val (pathv);
2234   int r;
2235
2236   caml_enter_blocking_section ();
2237   r = guestfs_rmdir (g, path);
2238   caml_leave_blocking_section ();
2239   if (r == -1)
2240     ocaml_guestfs_raise_error (g, "rmdir");
2241
2242   rv = Val_unit;
2243   CAMLreturn (rv);
2244 }
2245
2246 CAMLprim value
2247 ocaml_guestfs_rm_rf (value gv, value pathv)
2248 {
2249   CAMLparam2 (gv, pathv);
2250   CAMLlocal1 (rv);
2251
2252   guestfs_h *g = Guestfs_val (gv);
2253   if (g == NULL)
2254     caml_failwith ("rm_rf: used handle after closing it");
2255
2256   const char *path = String_val (pathv);
2257   int r;
2258
2259   caml_enter_blocking_section ();
2260   r = guestfs_rm_rf (g, path);
2261   caml_leave_blocking_section ();
2262   if (r == -1)
2263     ocaml_guestfs_raise_error (g, "rm_rf");
2264
2265   rv = Val_unit;
2266   CAMLreturn (rv);
2267 }
2268
2269 CAMLprim value
2270 ocaml_guestfs_mkdir (value gv, value pathv)
2271 {
2272   CAMLparam2 (gv, pathv);
2273   CAMLlocal1 (rv);
2274
2275   guestfs_h *g = Guestfs_val (gv);
2276   if (g == NULL)
2277     caml_failwith ("mkdir: used handle after closing it");
2278
2279   const char *path = String_val (pathv);
2280   int r;
2281
2282   caml_enter_blocking_section ();
2283   r = guestfs_mkdir (g, path);
2284   caml_leave_blocking_section ();
2285   if (r == -1)
2286     ocaml_guestfs_raise_error (g, "mkdir");
2287
2288   rv = Val_unit;
2289   CAMLreturn (rv);
2290 }
2291
2292 CAMLprim value
2293 ocaml_guestfs_mkdir_p (value gv, value pathv)
2294 {
2295   CAMLparam2 (gv, pathv);
2296   CAMLlocal1 (rv);
2297
2298   guestfs_h *g = Guestfs_val (gv);
2299   if (g == NULL)
2300     caml_failwith ("mkdir_p: used handle after closing it");
2301
2302   const char *path = String_val (pathv);
2303   int r;
2304
2305   caml_enter_blocking_section ();
2306   r = guestfs_mkdir_p (g, path);
2307   caml_leave_blocking_section ();
2308   if (r == -1)
2309     ocaml_guestfs_raise_error (g, "mkdir_p");
2310
2311   rv = Val_unit;
2312   CAMLreturn (rv);
2313 }
2314
2315 CAMLprim value
2316 ocaml_guestfs_chmod (value gv, value modev, value pathv)
2317 {
2318   CAMLparam3 (gv, modev, pathv);
2319   CAMLlocal1 (rv);
2320
2321   guestfs_h *g = Guestfs_val (gv);
2322   if (g == NULL)
2323     caml_failwith ("chmod: used handle after closing it");
2324
2325   int mode = Int_val (modev);
2326   const char *path = String_val (pathv);
2327   int r;
2328
2329   caml_enter_blocking_section ();
2330   r = guestfs_chmod (g, mode, path);
2331   caml_leave_blocking_section ();
2332   if (r == -1)
2333     ocaml_guestfs_raise_error (g, "chmod");
2334
2335   rv = Val_unit;
2336   CAMLreturn (rv);
2337 }
2338
2339 CAMLprim value
2340 ocaml_guestfs_chown (value gv, value ownerv, value groupv, value pathv)
2341 {
2342   CAMLparam4 (gv, ownerv, groupv, pathv);
2343   CAMLlocal1 (rv);
2344
2345   guestfs_h *g = Guestfs_val (gv);
2346   if (g == NULL)
2347     caml_failwith ("chown: used handle after closing it");
2348
2349   int owner = Int_val (ownerv);
2350   int group = Int_val (groupv);
2351   const char *path = String_val (pathv);
2352   int r;
2353
2354   caml_enter_blocking_section ();
2355   r = guestfs_chown (g, owner, group, path);
2356   caml_leave_blocking_section ();
2357   if (r == -1)
2358     ocaml_guestfs_raise_error (g, "chown");
2359
2360   rv = Val_unit;
2361   CAMLreturn (rv);
2362 }
2363
2364 CAMLprim value
2365 ocaml_guestfs_exists (value gv, value pathv)
2366 {
2367   CAMLparam2 (gv, pathv);
2368   CAMLlocal1 (rv);
2369
2370   guestfs_h *g = Guestfs_val (gv);
2371   if (g == NULL)
2372     caml_failwith ("exists: used handle after closing it");
2373
2374   const char *path = String_val (pathv);
2375   int r;
2376
2377   caml_enter_blocking_section ();
2378   r = guestfs_exists (g, path);
2379   caml_leave_blocking_section ();
2380   if (r == -1)
2381     ocaml_guestfs_raise_error (g, "exists");
2382
2383   rv = Val_bool (r);
2384   CAMLreturn (rv);
2385 }
2386
2387 CAMLprim value
2388 ocaml_guestfs_is_file (value gv, value pathv)
2389 {
2390   CAMLparam2 (gv, pathv);
2391   CAMLlocal1 (rv);
2392
2393   guestfs_h *g = Guestfs_val (gv);
2394   if (g == NULL)
2395     caml_failwith ("is_file: used handle after closing it");
2396
2397   const char *path = String_val (pathv);
2398   int r;
2399
2400   caml_enter_blocking_section ();
2401   r = guestfs_is_file (g, path);
2402   caml_leave_blocking_section ();
2403   if (r == -1)
2404     ocaml_guestfs_raise_error (g, "is_file");
2405
2406   rv = Val_bool (r);
2407   CAMLreturn (rv);
2408 }
2409
2410 CAMLprim value
2411 ocaml_guestfs_is_dir (value gv, value pathv)
2412 {
2413   CAMLparam2 (gv, pathv);
2414   CAMLlocal1 (rv);
2415
2416   guestfs_h *g = Guestfs_val (gv);
2417   if (g == NULL)
2418     caml_failwith ("is_dir: used handle after closing it");
2419
2420   const char *path = String_val (pathv);
2421   int r;
2422
2423   caml_enter_blocking_section ();
2424   r = guestfs_is_dir (g, path);
2425   caml_leave_blocking_section ();
2426   if (r == -1)
2427     ocaml_guestfs_raise_error (g, "is_dir");
2428
2429   rv = Val_bool (r);
2430   CAMLreturn (rv);
2431 }
2432
2433 CAMLprim value
2434 ocaml_guestfs_pvcreate (value gv, value devicev)
2435 {
2436   CAMLparam2 (gv, devicev);
2437   CAMLlocal1 (rv);
2438
2439   guestfs_h *g = Guestfs_val (gv);
2440   if (g == NULL)
2441     caml_failwith ("pvcreate: used handle after closing it");
2442
2443   const char *device = String_val (devicev);
2444   int r;
2445
2446   caml_enter_blocking_section ();
2447   r = guestfs_pvcreate (g, device);
2448   caml_leave_blocking_section ();
2449   if (r == -1)
2450     ocaml_guestfs_raise_error (g, "pvcreate");
2451
2452   rv = Val_unit;
2453   CAMLreturn (rv);
2454 }
2455
2456 CAMLprim value
2457 ocaml_guestfs_vgcreate (value gv, value volgroupv, value physvolsv)
2458 {
2459   CAMLparam3 (gv, volgroupv, physvolsv);
2460   CAMLlocal1 (rv);
2461
2462   guestfs_h *g = Guestfs_val (gv);
2463   if (g == NULL)
2464     caml_failwith ("vgcreate: used handle after closing it");
2465
2466   const char *volgroup = String_val (volgroupv);
2467   char **physvols = ocaml_guestfs_strings_val (g, physvolsv);
2468   int r;
2469
2470   caml_enter_blocking_section ();
2471   r = guestfs_vgcreate (g, volgroup, physvols);
2472   caml_leave_blocking_section ();
2473   ocaml_guestfs_free_strings (physvols);
2474   if (r == -1)
2475     ocaml_guestfs_raise_error (g, "vgcreate");
2476
2477   rv = Val_unit;
2478   CAMLreturn (rv);
2479 }
2480
2481 CAMLprim value
2482 ocaml_guestfs_lvcreate (value gv, value logvolv, value volgroupv, value mbytesv)
2483 {
2484   CAMLparam4 (gv, logvolv, volgroupv, mbytesv);
2485   CAMLlocal1 (rv);
2486
2487   guestfs_h *g = Guestfs_val (gv);
2488   if (g == NULL)
2489     caml_failwith ("lvcreate: used handle after closing it");
2490
2491   const char *logvol = String_val (logvolv);
2492   const char *volgroup = String_val (volgroupv);
2493   int mbytes = Int_val (mbytesv);
2494   int r;
2495
2496   caml_enter_blocking_section ();
2497   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2498   caml_leave_blocking_section ();
2499   if (r == -1)
2500     ocaml_guestfs_raise_error (g, "lvcreate");
2501
2502   rv = Val_unit;
2503   CAMLreturn (rv);
2504 }
2505
2506 CAMLprim value
2507 ocaml_guestfs_mkfs (value gv, value fstypev, value devicev)
2508 {
2509   CAMLparam3 (gv, fstypev, devicev);
2510   CAMLlocal1 (rv);
2511
2512   guestfs_h *g = Guestfs_val (gv);
2513   if (g == NULL)
2514     caml_failwith ("mkfs: used handle after closing it");
2515
2516   const char *fstype = String_val (fstypev);
2517   const char *device = String_val (devicev);
2518   int r;
2519
2520   caml_enter_blocking_section ();
2521   r = guestfs_mkfs (g, fstype, device);
2522   caml_leave_blocking_section ();
2523   if (r == -1)
2524     ocaml_guestfs_raise_error (g, "mkfs");
2525
2526   rv = Val_unit;
2527   CAMLreturn (rv);
2528 }
2529
2530 CAMLprim value
2531 ocaml_guestfs_sfdisk (value gv, value devicev, value cylsv, value headsv, value sectorsv, value linesv)
2532 {
2533   CAMLparam5 (gv, devicev, cylsv, headsv, sectorsv);
2534   CAMLxparam1 (linesv);
2535   CAMLlocal1 (rv);
2536
2537   guestfs_h *g = Guestfs_val (gv);
2538   if (g == NULL)
2539     caml_failwith ("sfdisk: used handle after closing it");
2540
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);
2546   int r;
2547
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);
2552   if (r == -1)
2553     ocaml_guestfs_raise_error (g, "sfdisk");
2554
2555   rv = Val_unit;
2556   CAMLreturn (rv);
2557 }
2558
2559 CAMLprim value
2560 ocaml_guestfs_sfdisk_byte (value *argv, int argn)
2561 {
2562   return ocaml_guestfs_sfdisk (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4]);
2563 }
2564
2565 CAMLprim value
2566 ocaml_guestfs_write_file (value gv, value pathv, value contentv, value sizev)
2567 {
2568   CAMLparam4 (gv, pathv, contentv, sizev);
2569   CAMLlocal1 (rv);
2570
2571   guestfs_h *g = Guestfs_val (gv);
2572   if (g == NULL)
2573     caml_failwith ("write_file: used handle after closing it");
2574
2575   const char *path = String_val (pathv);
2576   const char *content = String_val (contentv);
2577   int size = Int_val (sizev);
2578   int r;
2579
2580   caml_enter_blocking_section ();
2581   r = guestfs_write_file (g, path, content, size);
2582   caml_leave_blocking_section ();
2583   if (r == -1)
2584     ocaml_guestfs_raise_error (g, "write_file");
2585
2586   rv = Val_unit;
2587   CAMLreturn (rv);
2588 }
2589
2590 CAMLprim value
2591 ocaml_guestfs_umount (value gv, value pathordevicev)
2592 {
2593   CAMLparam2 (gv, pathordevicev);
2594   CAMLlocal1 (rv);
2595
2596   guestfs_h *g = Guestfs_val (gv);
2597   if (g == NULL)
2598     caml_failwith ("umount: used handle after closing it");
2599
2600   const char *pathordevice = String_val (pathordevicev);
2601   int r;
2602
2603   caml_enter_blocking_section ();
2604   r = guestfs_umount (g, pathordevice);
2605   caml_leave_blocking_section ();
2606   if (r == -1)
2607     ocaml_guestfs_raise_error (g, "umount");
2608
2609   rv = Val_unit;
2610   CAMLreturn (rv);
2611 }
2612
2613 CAMLprim value
2614 ocaml_guestfs_mounts (value gv)
2615 {
2616   CAMLparam1 (gv);
2617   CAMLlocal1 (rv);
2618
2619   guestfs_h *g = Guestfs_val (gv);
2620   if (g == NULL)
2621     caml_failwith ("mounts: used handle after closing it");
2622
2623   int i;
2624   char **r;
2625
2626   caml_enter_blocking_section ();
2627   r = guestfs_mounts (g);
2628   caml_leave_blocking_section ();
2629   if (r == NULL)
2630     ocaml_guestfs_raise_error (g, "mounts");
2631
2632   rv = caml_copy_string_array ((const char **) r);
2633   for (i = 0; r[i] != NULL; ++i) free (r[i]);
2634   free (r);
2635   CAMLreturn (rv);
2636 }
2637
2638 CAMLprim value
2639 ocaml_guestfs_umount_all (value gv)
2640 {
2641   CAMLparam1 (gv);
2642   CAMLlocal1 (rv);
2643
2644   guestfs_h *g = Guestfs_val (gv);
2645   if (g == NULL)
2646     caml_failwith ("umount_all: used handle after closing it");
2647
2648   int r;
2649
2650   caml_enter_blocking_section ();
2651   r = guestfs_umount_all (g);
2652   caml_leave_blocking_section ();
2653   if (r == -1)
2654     ocaml_guestfs_raise_error (g, "umount_all");
2655
2656   rv = Val_unit;
2657   CAMLreturn (rv);
2658 }
2659
2660 CAMLprim value
2661 ocaml_guestfs_lvm_remove_all (value gv)
2662 {
2663   CAMLparam1 (gv);
2664   CAMLlocal1 (rv);
2665
2666   guestfs_h *g = Guestfs_val (gv);
2667   if (g == NULL)
2668     caml_failwith ("lvm_remove_all: used handle after closing it");
2669
2670   int r;
2671
2672   caml_enter_blocking_section ();
2673   r = guestfs_lvm_remove_all (g);
2674   caml_leave_blocking_section ();
2675   if (r == -1)
2676     ocaml_guestfs_raise_error (g, "lvm_remove_all");
2677
2678   rv = Val_unit;
2679   CAMLreturn (rv);
2680 }
2681
2682 CAMLprim value
2683 ocaml_guestfs_file (value gv, value pathv)
2684 {
2685   CAMLparam2 (gv, pathv);
2686   CAMLlocal1 (rv);
2687
2688   guestfs_h *g = Guestfs_val (gv);
2689   if (g == NULL)
2690     caml_failwith ("file: used handle after closing it");
2691
2692   const char *path = String_val (pathv);
2693   char *r;
2694
2695   caml_enter_blocking_section ();
2696   r = guestfs_file (g, path);
2697   caml_leave_blocking_section ();
2698   if (r == NULL)
2699     ocaml_guestfs_raise_error (g, "file");
2700
2701   rv = caml_copy_string (r);
2702   free (r);
2703   CAMLreturn (rv);
2704 }
2705
2706 CAMLprim value
2707 ocaml_guestfs_command (value gv, value argumentsv)
2708 {
2709   CAMLparam2 (gv, argumentsv);
2710   CAMLlocal1 (rv);
2711
2712   guestfs_h *g = Guestfs_val (gv);
2713   if (g == NULL)
2714     caml_failwith ("command: used handle after closing it");
2715
2716   char **arguments = ocaml_guestfs_strings_val (g, argumentsv);
2717   char *r;
2718
2719   caml_enter_blocking_section ();
2720   r = guestfs_command (g, arguments);
2721   caml_leave_blocking_section ();
2722   ocaml_guestfs_free_strings (arguments);
2723   if (r == NULL)
2724     ocaml_guestfs_raise_error (g, "command");
2725
2726   rv = caml_copy_string (r);
2727   free (r);
2728   CAMLreturn (rv);
2729 }
2730
2731 CAMLprim value
2732 ocaml_guestfs_command_lines (value gv, value argumentsv)
2733 {
2734   CAMLparam2 (gv, argumentsv);
2735   CAMLlocal1 (rv);
2736
2737   guestfs_h *g = Guestfs_val (gv);
2738   if (g == NULL)
2739     caml_failwith ("command_lines: used handle after closing it");
2740
2741   char **arguments = ocaml_guestfs_strings_val (g, argumentsv);
2742   int i;
2743   char **r;
2744
2745   caml_enter_blocking_section ();
2746   r = guestfs_command_lines (g, arguments);
2747   caml_leave_blocking_section ();
2748   ocaml_guestfs_free_strings (arguments);
2749   if (r == NULL)
2750     ocaml_guestfs_raise_error (g, "command_lines");
2751
2752   rv = caml_copy_string_array ((const char **) r);
2753   for (i = 0; r[i] != NULL; ++i) free (r[i]);
2754   free (r);
2755   CAMLreturn (rv);
2756 }
2757
2758 CAMLprim value
2759 ocaml_guestfs_stat (value gv, value pathv)
2760 {
2761   CAMLparam2 (gv, pathv);
2762   CAMLlocal1 (rv);
2763
2764   guestfs_h *g = Guestfs_val (gv);
2765   if (g == NULL)
2766     caml_failwith ("stat: used handle after closing it");
2767
2768   const char *path = String_val (pathv);
2769   struct guestfs_stat *r;
2770
2771   caml_enter_blocking_section ();
2772   r = guestfs_stat (g, path);
2773   caml_leave_blocking_section ();
2774   if (r == NULL)
2775     ocaml_guestfs_raise_error (g, "stat");
2776
2777   rv = copy_stat (r);
2778   free (r);
2779   CAMLreturn (rv);
2780 }
2781
2782 CAMLprim value
2783 ocaml_guestfs_lstat (value gv, value pathv)
2784 {
2785   CAMLparam2 (gv, pathv);
2786   CAMLlocal1 (rv);
2787
2788   guestfs_h *g = Guestfs_val (gv);
2789   if (g == NULL)
2790     caml_failwith ("lstat: used handle after closing it");
2791
2792   const char *path = String_val (pathv);
2793   struct guestfs_stat *r;
2794
2795   caml_enter_blocking_section ();
2796   r = guestfs_lstat (g, path);
2797   caml_leave_blocking_section ();
2798   if (r == NULL)
2799     ocaml_guestfs_raise_error (g, "lstat");
2800
2801   rv = copy_stat (r);
2802   free (r);
2803   CAMLreturn (rv);
2804 }
2805
2806 CAMLprim value
2807 ocaml_guestfs_statvfs (value gv, value pathv)
2808 {
2809   CAMLparam2 (gv, pathv);
2810   CAMLlocal1 (rv);
2811
2812   guestfs_h *g = Guestfs_val (gv);
2813   if (g == NULL)
2814     caml_failwith ("statvfs: used handle after closing it");
2815
2816   const char *path = String_val (pathv);
2817   struct guestfs_statvfs *r;
2818
2819   caml_enter_blocking_section ();
2820   r = guestfs_statvfs (g, path);
2821   caml_leave_blocking_section ();
2822   if (r == NULL)
2823     ocaml_guestfs_raise_error (g, "statvfs");
2824
2825   rv = copy_statvfs (r);
2826   free (r);
2827   CAMLreturn (rv);
2828 }
2829
2830 CAMLprim value
2831 ocaml_guestfs_tune2fs_l (value gv, value devicev)
2832 {
2833   CAMLparam2 (gv, devicev);
2834   CAMLlocal1 (rv);
2835
2836   guestfs_h *g = Guestfs_val (gv);
2837   if (g == NULL)
2838     caml_failwith ("tune2fs_l: used handle after closing it");
2839
2840   const char *device = String_val (devicev);
2841   int i;
2842   char **r;
2843
2844   caml_enter_blocking_section ();
2845   r = guestfs_tune2fs_l (g, device);
2846   caml_leave_blocking_section ();
2847   if (r == NULL)
2848     ocaml_guestfs_raise_error (g, "tune2fs_l");
2849
2850   rv = copy_table (r);
2851   for (i = 0; r[i] != NULL; ++i) free (r[i]);
2852   free (r);
2853   CAMLreturn (rv);
2854 }
2855
2856 CAMLprim value
2857 ocaml_guestfs_blockdev_setro (value gv, value devicev)
2858 {
2859   CAMLparam2 (gv, devicev);
2860   CAMLlocal1 (rv);
2861
2862   guestfs_h *g = Guestfs_val (gv);
2863   if (g == NULL)
2864     caml_failwith ("blockdev_setro: used handle after closing it");
2865
2866   const char *device = String_val (devicev);
2867   int r;
2868
2869   caml_enter_blocking_section ();
2870   r = guestfs_blockdev_setro (g, device);
2871   caml_leave_blocking_section ();
2872   if (r == -1)
2873     ocaml_guestfs_raise_error (g, "blockdev_setro");
2874
2875   rv = Val_unit;
2876   CAMLreturn (rv);
2877 }
2878
2879 CAMLprim value
2880 ocaml_guestfs_blockdev_setrw (value gv, value devicev)
2881 {
2882   CAMLparam2 (gv, devicev);
2883   CAMLlocal1 (rv);
2884
2885   guestfs_h *g = Guestfs_val (gv);
2886   if (g == NULL)
2887     caml_failwith ("blockdev_setrw: used handle after closing it");
2888
2889   const char *device = String_val (devicev);
2890   int r;
2891
2892   caml_enter_blocking_section ();
2893   r = guestfs_blockdev_setrw (g, device);
2894   caml_leave_blocking_section ();
2895   if (r == -1)
2896     ocaml_guestfs_raise_error (g, "blockdev_setrw");
2897
2898   rv = Val_unit;
2899   CAMLreturn (rv);
2900 }
2901
2902 CAMLprim value
2903 ocaml_guestfs_blockdev_getro (value gv, value devicev)
2904 {
2905   CAMLparam2 (gv, devicev);
2906   CAMLlocal1 (rv);
2907
2908   guestfs_h *g = Guestfs_val (gv);
2909   if (g == NULL)
2910     caml_failwith ("blockdev_getro: used handle after closing it");
2911
2912   const char *device = String_val (devicev);
2913   int r;
2914
2915   caml_enter_blocking_section ();
2916   r = guestfs_blockdev_getro (g, device);
2917   caml_leave_blocking_section ();
2918   if (r == -1)
2919     ocaml_guestfs_raise_error (g, "blockdev_getro");
2920
2921   rv = Val_bool (r);
2922   CAMLreturn (rv);
2923 }
2924
2925 CAMLprim value
2926 ocaml_guestfs_blockdev_getss (value gv, value devicev)
2927 {
2928   CAMLparam2 (gv, devicev);
2929   CAMLlocal1 (rv);
2930
2931   guestfs_h *g = Guestfs_val (gv);
2932   if (g == NULL)
2933     caml_failwith ("blockdev_getss: used handle after closing it");
2934
2935   const char *device = String_val (devicev);
2936   int r;
2937
2938   caml_enter_blocking_section ();
2939   r = guestfs_blockdev_getss (g, device);
2940   caml_leave_blocking_section ();
2941   if (r == -1)
2942     ocaml_guestfs_raise_error (g, "blockdev_getss");
2943
2944   rv = Val_int (r);
2945   CAMLreturn (rv);
2946 }
2947
2948 CAMLprim value
2949 ocaml_guestfs_blockdev_getbsz (value gv, value devicev)
2950 {
2951   CAMLparam2 (gv, devicev);
2952   CAMLlocal1 (rv);
2953
2954   guestfs_h *g = Guestfs_val (gv);
2955   if (g == NULL)
2956     caml_failwith ("blockdev_getbsz: used handle after closing it");
2957
2958   const char *device = String_val (devicev);
2959   int r;
2960
2961   caml_enter_blocking_section ();
2962   r = guestfs_blockdev_getbsz (g, device);
2963   caml_leave_blocking_section ();
2964   if (r == -1)
2965     ocaml_guestfs_raise_error (g, "blockdev_getbsz");
2966
2967   rv = Val_int (r);
2968   CAMLreturn (rv);
2969 }
2970
2971 CAMLprim value
2972 ocaml_guestfs_blockdev_setbsz (value gv, value devicev, value blocksizev)
2973 {
2974   CAMLparam3 (gv, devicev, blocksizev);
2975   CAMLlocal1 (rv);
2976
2977   guestfs_h *g = Guestfs_val (gv);
2978   if (g == NULL)
2979     caml_failwith ("blockdev_setbsz: used handle after closing it");
2980
2981   const char *device = String_val (devicev);
2982   int blocksize = Int_val (blocksizev);
2983   int r;
2984
2985   caml_enter_blocking_section ();
2986   r = guestfs_blockdev_setbsz (g, device, blocksize);
2987   caml_leave_blocking_section ();
2988   if (r == -1)
2989     ocaml_guestfs_raise_error (g, "blockdev_setbsz");
2990
2991   rv = Val_unit;
2992   CAMLreturn (rv);
2993 }
2994
2995 CAMLprim value
2996 ocaml_guestfs_blockdev_getsz (value gv, value devicev)
2997 {
2998   CAMLparam2 (gv, devicev);
2999   CAMLlocal1 (rv);
3000
3001   guestfs_h *g = Guestfs_val (gv);
3002   if (g == NULL)
3003     caml_failwith ("blockdev_getsz: used handle after closing it");
3004
3005   const char *device = String_val (devicev);
3006   int64_t r;
3007
3008   caml_enter_blocking_section ();
3009   r = guestfs_blockdev_getsz (g, device);
3010   caml_leave_blocking_section ();
3011   if (r == -1)
3012     ocaml_guestfs_raise_error (g, "blockdev_getsz");
3013
3014   rv = caml_copy_int64 (r);
3015   CAMLreturn (rv);
3016 }
3017
3018 CAMLprim value
3019 ocaml_guestfs_blockdev_getsize64 (value gv, value devicev)
3020 {
3021   CAMLparam2 (gv, devicev);
3022   CAMLlocal1 (rv);
3023
3024   guestfs_h *g = Guestfs_val (gv);
3025   if (g == NULL)
3026     caml_failwith ("blockdev_getsize64: used handle after closing it");
3027
3028   const char *device = String_val (devicev);
3029   int64_t r;
3030
3031   caml_enter_blocking_section ();
3032   r = guestfs_blockdev_getsize64 (g, device);
3033   caml_leave_blocking_section ();
3034   if (r == -1)
3035     ocaml_guestfs_raise_error (g, "blockdev_getsize64");
3036
3037   rv = caml_copy_int64 (r);
3038   CAMLreturn (rv);
3039 }
3040
3041 CAMLprim value
3042 ocaml_guestfs_blockdev_flushbufs (value gv, value devicev)
3043 {
3044   CAMLparam2 (gv, devicev);
3045   CAMLlocal1 (rv);
3046
3047   guestfs_h *g = Guestfs_val (gv);
3048   if (g == NULL)
3049     caml_failwith ("blockdev_flushbufs: used handle after closing it");
3050
3051   const char *device = String_val (devicev);
3052   int r;
3053
3054   caml_enter_blocking_section ();
3055   r = guestfs_blockdev_flushbufs (g, device);
3056   caml_leave_blocking_section ();
3057   if (r == -1)
3058     ocaml_guestfs_raise_error (g, "blockdev_flushbufs");
3059
3060   rv = Val_unit;
3061   CAMLreturn (rv);
3062 }
3063
3064 CAMLprim value
3065 ocaml_guestfs_blockdev_rereadpt (value gv, value devicev)
3066 {
3067   CAMLparam2 (gv, devicev);
3068   CAMLlocal1 (rv);
3069
3070   guestfs_h *g = Guestfs_val (gv);
3071   if (g == NULL)
3072     caml_failwith ("blockdev_rereadpt: used handle after closing it");
3073
3074   const char *device = String_val (devicev);
3075   int r;
3076
3077   caml_enter_blocking_section ();
3078   r = guestfs_blockdev_rereadpt (g, device);
3079   caml_leave_blocking_section ();
3080   if (r == -1)
3081     ocaml_guestfs_raise_error (g, "blockdev_rereadpt");
3082
3083   rv = Val_unit;
3084   CAMLreturn (rv);
3085 }
3086
3087 CAMLprim value
3088 ocaml_guestfs_upload (value gv, value filenamev, value remotefilenamev)
3089 {
3090   CAMLparam3 (gv, filenamev, remotefilenamev);
3091   CAMLlocal1 (rv);
3092
3093   guestfs_h *g = Guestfs_val (gv);
3094   if (g == NULL)
3095     caml_failwith ("upload: used handle after closing it");
3096
3097   const char *filename = String_val (filenamev);
3098   const char *remotefilename = String_val (remotefilenamev);
3099   int r;
3100
3101   caml_enter_blocking_section ();
3102   r = guestfs_upload (g, filename, remotefilename);
3103   caml_leave_blocking_section ();
3104   if (r == -1)
3105     ocaml_guestfs_raise_error (g, "upload");
3106
3107   rv = Val_unit;
3108   CAMLreturn (rv);
3109 }
3110
3111 CAMLprim value
3112 ocaml_guestfs_download (value gv, value remotefilenamev, value filenamev)
3113 {
3114   CAMLparam3 (gv, remotefilenamev, filenamev);
3115   CAMLlocal1 (rv);
3116
3117   guestfs_h *g = Guestfs_val (gv);
3118   if (g == NULL)
3119     caml_failwith ("download: used handle after closing it");
3120
3121   const char *remotefilename = String_val (remotefilenamev);
3122   const char *filename = String_val (filenamev);
3123   int r;
3124
3125   caml_enter_blocking_section ();
3126   r = guestfs_download (g, remotefilename, filename);
3127   caml_leave_blocking_section ();
3128   if (r == -1)
3129     ocaml_guestfs_raise_error (g, "download");
3130
3131   rv = Val_unit;
3132   CAMLreturn (rv);
3133 }
3134
3135 CAMLprim value
3136 ocaml_guestfs_checksum (value gv, value csumtypev, value pathv)
3137 {
3138   CAMLparam3 (gv, csumtypev, pathv);
3139   CAMLlocal1 (rv);
3140
3141   guestfs_h *g = Guestfs_val (gv);
3142   if (g == NULL)
3143     caml_failwith ("checksum: used handle after closing it");
3144
3145   const char *csumtype = String_val (csumtypev);
3146   const char *path = String_val (pathv);
3147   char *r;
3148
3149   caml_enter_blocking_section ();
3150   r = guestfs_checksum (g, csumtype, path);
3151   caml_leave_blocking_section ();
3152   if (r == NULL)
3153     ocaml_guestfs_raise_error (g, "checksum");
3154
3155   rv = caml_copy_string (r);
3156   free (r);
3157   CAMLreturn (rv);
3158 }
3159
3160 CAMLprim value
3161 ocaml_guestfs_tar_in (value gv, value tarfilev, value directoryv)
3162 {
3163   CAMLparam3 (gv, tarfilev, directoryv);
3164   CAMLlocal1 (rv);
3165
3166   guestfs_h *g = Guestfs_val (gv);
3167   if (g == NULL)
3168     caml_failwith ("tar_in: used handle after closing it");
3169
3170   const char *tarfile = String_val (tarfilev);
3171   const char *directory = String_val (directoryv);
3172   int r;
3173
3174   caml_enter_blocking_section ();
3175   r = guestfs_tar_in (g, tarfile, directory);
3176   caml_leave_blocking_section ();
3177   if (r == -1)
3178     ocaml_guestfs_raise_error (g, "tar_in");
3179
3180   rv = Val_unit;
3181   CAMLreturn (rv);
3182 }
3183
3184 CAMLprim value
3185 ocaml_guestfs_tar_out (value gv, value directoryv, value tarfilev)
3186 {
3187   CAMLparam3 (gv, directoryv, tarfilev);
3188   CAMLlocal1 (rv);
3189
3190   guestfs_h *g = Guestfs_val (gv);
3191   if (g == NULL)
3192     caml_failwith ("tar_out: used handle after closing it");
3193
3194   const char *directory = String_val (directoryv);
3195   const char *tarfile = String_val (tarfilev);
3196   int r;
3197
3198   caml_enter_blocking_section ();
3199   r = guestfs_tar_out (g, directory, tarfile);
3200   caml_leave_blocking_section ();
3201   if (r == -1)
3202     ocaml_guestfs_raise_error (g, "tar_out");
3203
3204   rv = Val_unit;
3205   CAMLreturn (rv);
3206 }
3207
3208 CAMLprim value
3209 ocaml_guestfs_tgz_in (value gv, value tarballv, value directoryv)
3210 {
3211   CAMLparam3 (gv, tarballv, directoryv);
3212   CAMLlocal1 (rv);
3213
3214   guestfs_h *g = Guestfs_val (gv);
3215   if (g == NULL)
3216     caml_failwith ("tgz_in: used handle after closing it");
3217
3218   const char *tarball = String_val (tarballv);
3219   const char *directory = String_val (directoryv);
3220   int r;
3221
3222   caml_enter_blocking_section ();
3223   r = guestfs_tgz_in (g, tarball, directory);
3224   caml_leave_blocking_section ();
3225   if (r == -1)
3226     ocaml_guestfs_raise_error (g, "tgz_in");
3227
3228   rv = Val_unit;
3229   CAMLreturn (rv);
3230 }
3231
3232 CAMLprim value
3233 ocaml_guestfs_tgz_out (value gv, value directoryv, value tarballv)
3234 {
3235   CAMLparam3 (gv, directoryv, tarballv);
3236   CAMLlocal1 (rv);
3237
3238   guestfs_h *g = Guestfs_val (gv);
3239   if (g == NULL)
3240     caml_failwith ("tgz_out: used handle after closing it");
3241
3242   const char *directory = String_val (directoryv);
3243   const char *tarball = String_val (tarballv);
3244   int r;
3245
3246   caml_enter_blocking_section ();
3247   r = guestfs_tgz_out (g, directory, tarball);
3248   caml_leave_blocking_section ();
3249   if (r == -1)
3250     ocaml_guestfs_raise_error (g, "tgz_out");
3251
3252   rv = Val_unit;
3253   CAMLreturn (rv);
3254 }
3255
3256 CAMLprim value
3257 ocaml_guestfs_mount_ro (value gv, value devicev, value mountpointv)
3258 {
3259   CAMLparam3 (gv, devicev, mountpointv);
3260   CAMLlocal1 (rv);
3261
3262   guestfs_h *g = Guestfs_val (gv);
3263   if (g == NULL)
3264     caml_failwith ("mount_ro: used handle after closing it");
3265
3266   const char *device = String_val (devicev);
3267   const char *mountpoint = String_val (mountpointv);
3268   int r;
3269
3270   caml_enter_blocking_section ();
3271   r = guestfs_mount_ro (g, device, mountpoint);
3272   caml_leave_blocking_section ();
3273   if (r == -1)
3274     ocaml_guestfs_raise_error (g, "mount_ro");
3275
3276   rv = Val_unit;
3277   CAMLreturn (rv);
3278 }
3279
3280 CAMLprim value
3281 ocaml_guestfs_mount_options (value gv, value optionsv, value devicev, value mountpointv)
3282 {
3283   CAMLparam4 (gv, optionsv, devicev, mountpointv);
3284   CAMLlocal1 (rv);
3285
3286   guestfs_h *g = Guestfs_val (gv);
3287   if (g == NULL)
3288     caml_failwith ("mount_options: used handle after closing it");
3289
3290   const char *options = String_val (optionsv);
3291   const char *device = String_val (devicev);
3292   const char *mountpoint = String_val (mountpointv);
3293   int r;
3294
3295   caml_enter_blocking_section ();
3296   r = guestfs_mount_options (g, options, device, mountpoint);
3297   caml_leave_blocking_section ();
3298   if (r == -1)
3299     ocaml_guestfs_raise_error (g, "mount_options");
3300
3301   rv = Val_unit;
3302   CAMLreturn (rv);
3303 }
3304
3305 CAMLprim value
3306 ocaml_guestfs_mount_vfs (value gv, value optionsv, value vfstypev, value devicev, value mountpointv)
3307 {
3308   CAMLparam5 (gv, optionsv, vfstypev, devicev, mountpointv);
3309   CAMLlocal1 (rv);
3310
3311   guestfs_h *g = Guestfs_val (gv);
3312   if (g == NULL)
3313     caml_failwith ("mount_vfs: used handle after closing it");
3314
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);
3319   int r;
3320
3321   caml_enter_blocking_section ();
3322   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3323   caml_leave_blocking_section ();
3324   if (r == -1)
3325     ocaml_guestfs_raise_error (g, "mount_vfs");
3326
3327   rv = Val_unit;
3328   CAMLreturn (rv);
3329 }
3330
3331 CAMLprim value
3332 ocaml_guestfs_debug (value gv, value subcmdv, value extraargsv)
3333 {
3334   CAMLparam3 (gv, subcmdv, extraargsv);
3335   CAMLlocal1 (rv);
3336
3337   guestfs_h *g = Guestfs_val (gv);
3338   if (g == NULL)
3339     caml_failwith ("debug: used handle after closing it");
3340
3341   const char *subcmd = String_val (subcmdv);
3342   char **extraargs = ocaml_guestfs_strings_val (g, extraargsv);
3343   char *r;
3344
3345   caml_enter_blocking_section ();
3346   r = guestfs_debug (g, subcmd, extraargs);
3347   caml_leave_blocking_section ();
3348   ocaml_guestfs_free_strings (extraargs);
3349   if (r == NULL)
3350     ocaml_guestfs_raise_error (g, "debug");
3351
3352   rv = caml_copy_string (r);
3353   free (r);
3354   CAMLreturn (rv);
3355 }
3356
3357 CAMLprim value
3358 ocaml_guestfs_lvremove (value gv, value devicev)
3359 {
3360   CAMLparam2 (gv, devicev);
3361   CAMLlocal1 (rv);
3362
3363   guestfs_h *g = Guestfs_val (gv);
3364   if (g == NULL)
3365     caml_failwith ("lvremove: used handle after closing it");
3366
3367   const char *device = String_val (devicev);
3368   int r;
3369
3370   caml_enter_blocking_section ();
3371   r = guestfs_lvremove (g, device);
3372   caml_leave_blocking_section ();
3373   if (r == -1)
3374     ocaml_guestfs_raise_error (g, "lvremove");
3375
3376   rv = Val_unit;
3377   CAMLreturn (rv);
3378 }
3379
3380 CAMLprim value
3381 ocaml_guestfs_vgremove (value gv, value vgnamev)
3382 {
3383   CAMLparam2 (gv, vgnamev);
3384   CAMLlocal1 (rv);
3385
3386   guestfs_h *g = Guestfs_val (gv);
3387   if (g == NULL)
3388     caml_failwith ("vgremove: used handle after closing it");
3389
3390   const char *vgname = String_val (vgnamev);
3391   int r;
3392
3393   caml_enter_blocking_section ();
3394   r = guestfs_vgremove (g, vgname);
3395   caml_leave_blocking_section ();
3396   if (r == -1)
3397     ocaml_guestfs_raise_error (g, "vgremove");
3398
3399   rv = Val_unit;
3400   CAMLreturn (rv);
3401 }
3402
3403 CAMLprim value
3404 ocaml_guestfs_pvremove (value gv, value devicev)
3405 {
3406   CAMLparam2 (gv, devicev);
3407   CAMLlocal1 (rv);
3408
3409   guestfs_h *g = Guestfs_val (gv);
3410   if (g == NULL)
3411     caml_failwith ("pvremove: used handle after closing it");
3412
3413   const char *device = String_val (devicev);
3414   int r;
3415
3416   caml_enter_blocking_section ();
3417   r = guestfs_pvremove (g, device);
3418   caml_leave_blocking_section ();
3419   if (r == -1)
3420     ocaml_guestfs_raise_error (g, "pvremove");
3421
3422   rv = Val_unit;
3423   CAMLreturn (rv);
3424 }
3425
3426 CAMLprim value
3427 ocaml_guestfs_set_e2label (value gv, value devicev, value labelv)
3428 {
3429   CAMLparam3 (gv, devicev, labelv);
3430   CAMLlocal1 (rv);
3431
3432   guestfs_h *g = Guestfs_val (gv);
3433   if (g == NULL)
3434     caml_failwith ("set_e2label: used handle after closing it");
3435
3436   const char *device = String_val (devicev);
3437   const char *label = String_val (labelv);
3438   int r;
3439
3440   caml_enter_blocking_section ();
3441   r = guestfs_set_e2label (g, device, label);
3442   caml_leave_blocking_section ();
3443   if (r == -1)
3444     ocaml_guestfs_raise_error (g, "set_e2label");
3445
3446   rv = Val_unit;
3447   CAMLreturn (rv);
3448 }
3449
3450 CAMLprim value
3451 ocaml_guestfs_get_e2label (value gv, value devicev)
3452 {
3453   CAMLparam2 (gv, devicev);
3454   CAMLlocal1 (rv);
3455
3456   guestfs_h *g = Guestfs_val (gv);
3457   if (g == NULL)
3458     caml_failwith ("get_e2label: used handle after closing it");
3459
3460   const char *device = String_val (devicev);
3461   char *r;
3462
3463   caml_enter_blocking_section ();
3464   r = guestfs_get_e2label (g, device);
3465   caml_leave_blocking_section ();
3466   if (r == NULL)
3467     ocaml_guestfs_raise_error (g, "get_e2label");
3468
3469   rv = caml_copy_string (r);
3470   free (r);
3471   CAMLreturn (rv);
3472 }
3473
3474 CAMLprim value
3475 ocaml_guestfs_set_e2uuid (value gv, value devicev, value uuidv)
3476 {
3477   CAMLparam3 (gv, devicev, uuidv);
3478   CAMLlocal1 (rv);
3479
3480   guestfs_h *g = Guestfs_val (gv);
3481   if (g == NULL)
3482     caml_failwith ("set_e2uuid: used handle after closing it");
3483
3484   const char *device = String_val (devicev);
3485   const char *uuid = String_val (uuidv);
3486   int r;
3487
3488   caml_enter_blocking_section ();
3489   r = guestfs_set_e2uuid (g, device, uuid);
3490   caml_leave_blocking_section ();
3491   if (r == -1)
3492     ocaml_guestfs_raise_error (g, "set_e2uuid");
3493
3494   rv = Val_unit;
3495   CAMLreturn (rv);
3496 }
3497
3498 CAMLprim value
3499 ocaml_guestfs_get_e2uuid (value gv, value devicev)
3500 {
3501   CAMLparam2 (gv, devicev);
3502   CAMLlocal1 (rv);
3503
3504   guestfs_h *g = Guestfs_val (gv);
3505   if (g == NULL)
3506     caml_failwith ("get_e2uuid: used handle after closing it");
3507
3508   const char *device = String_val (devicev);
3509   char *r;
3510
3511   caml_enter_blocking_section ();
3512   r = guestfs_get_e2uuid (g, device);
3513   caml_leave_blocking_section ();
3514   if (r == NULL)
3515     ocaml_guestfs_raise_error (g, "get_e2uuid");
3516
3517   rv = caml_copy_string (r);
3518   free (r);
3519   CAMLreturn (rv);
3520 }
3521
3522 CAMLprim value
3523 ocaml_guestfs_fsck (value gv, value fstypev, value devicev)
3524 {
3525   CAMLparam3 (gv, fstypev, devicev);
3526   CAMLlocal1 (rv);
3527
3528   guestfs_h *g = Guestfs_val (gv);
3529   if (g == NULL)
3530     caml_failwith ("fsck: used handle after closing it");
3531
3532   const char *fstype = String_val (fstypev);
3533   const char *device = String_val (devicev);
3534   int r;
3535
3536   caml_enter_blocking_section ();
3537   r = guestfs_fsck (g, fstype, device);
3538   caml_leave_blocking_section ();
3539   if (r == -1)
3540     ocaml_guestfs_raise_error (g, "fsck");
3541
3542   rv = Val_int (r);
3543   CAMLreturn (rv);
3544 }
3545
3546 CAMLprim value
3547 ocaml_guestfs_zero (value gv, value devicev)
3548 {
3549   CAMLparam2 (gv, devicev);
3550   CAMLlocal1 (rv);
3551
3552   guestfs_h *g = Guestfs_val (gv);
3553   if (g == NULL)
3554     caml_failwith ("zero: used handle after closing it");
3555
3556   const char *device = String_val (devicev);
3557   int r;
3558
3559   caml_enter_blocking_section ();
3560   r = guestfs_zero (g, device);
3561   caml_leave_blocking_section ();
3562   if (r == -1)
3563     ocaml_guestfs_raise_error (g, "zero");
3564
3565   rv = Val_unit;
3566   CAMLreturn (rv);
3567 }
3568
3569 CAMLprim value
3570 ocaml_guestfs_grub_install (value gv, value rootv, value devicev)
3571 {
3572   CAMLparam3 (gv, rootv, devicev);
3573   CAMLlocal1 (rv);
3574
3575   guestfs_h *g = Guestfs_val (gv);
3576   if (g == NULL)
3577     caml_failwith ("grub_install: used handle after closing it");
3578
3579   const char *root = String_val (rootv);
3580   const char *device = String_val (devicev);
3581   int r;
3582
3583   caml_enter_blocking_section ();
3584   r = guestfs_grub_install (g, root, device);
3585   caml_leave_blocking_section ();
3586   if (r == -1)
3587     ocaml_guestfs_raise_error (g, "grub_install");
3588
3589   rv = Val_unit;
3590   CAMLreturn (rv);
3591 }
3592
3593 CAMLprim value
3594 ocaml_guestfs_cp (value gv, value srcv, value destv)
3595 {
3596   CAMLparam3 (gv, srcv, destv);
3597   CAMLlocal1 (rv);
3598
3599   guestfs_h *g = Guestfs_val (gv);
3600   if (g == NULL)
3601     caml_failwith ("cp: used handle after closing it");
3602
3603   const char *src = String_val (srcv);
3604   const char *dest = String_val (destv);
3605   int r;
3606
3607   caml_enter_blocking_section ();
3608   r = guestfs_cp (g, src, dest);
3609   caml_leave_blocking_section ();
3610   if (r == -1)
3611     ocaml_guestfs_raise_error (g, "cp");
3612
3613   rv = Val_unit;
3614   CAMLreturn (rv);
3615 }
3616
3617 CAMLprim value
3618 ocaml_guestfs_cp_a (value gv, value srcv, value destv)
3619 {
3620   CAMLparam3 (gv, srcv, destv);
3621   CAMLlocal1 (rv);
3622
3623   guestfs_h *g = Guestfs_val (gv);
3624   if (g == NULL)
3625     caml_failwith ("cp_a: used handle after closing it");
3626
3627   const char *src = String_val (srcv);
3628   const char *dest = String_val (destv);
3629   int r;
3630
3631   caml_enter_blocking_section ();
3632   r = guestfs_cp_a (g, src, dest);
3633   caml_leave_blocking_section ();
3634   if (r == -1)
3635     ocaml_guestfs_raise_error (g, "cp_a");
3636
3637   rv = Val_unit;
3638   CAMLreturn (rv);
3639 }
3640
3641 CAMLprim value
3642 ocaml_guestfs_mv (value gv, value srcv, value destv)
3643 {
3644   CAMLparam3 (gv, srcv, destv);
3645   CAMLlocal1 (rv);
3646
3647   guestfs_h *g = Guestfs_val (gv);
3648   if (g == NULL)
3649     caml_failwith ("mv: used handle after closing it");
3650
3651   const char *src = String_val (srcv);
3652   const char *dest = String_val (destv);
3653   int r;
3654
3655   caml_enter_blocking_section ();
3656   r = guestfs_mv (g, src, dest);
3657   caml_leave_blocking_section ();
3658   if (r == -1)
3659     ocaml_guestfs_raise_error (g, "mv");
3660
3661   rv = Val_unit;
3662   CAMLreturn (rv);
3663 }
3664
3665 CAMLprim value
3666 ocaml_guestfs_drop_caches (value gv, value whattodropv)
3667 {
3668   CAMLparam2 (gv, whattodropv);
3669   CAMLlocal1 (rv);
3670
3671   guestfs_h *g = Guestfs_val (gv);
3672   if (g == NULL)
3673     caml_failwith ("drop_caches: used handle after closing it");
3674
3675   int whattodrop = Int_val (whattodropv);
3676   int r;
3677
3678   caml_enter_blocking_section ();
3679   r = guestfs_drop_caches (g, whattodrop);
3680   caml_leave_blocking_section ();
3681   if (r == -1)
3682     ocaml_guestfs_raise_error (g, "drop_caches");
3683
3684   rv = Val_unit;
3685   CAMLreturn (rv);
3686 }
3687
3688 CAMLprim value
3689 ocaml_guestfs_dmesg (value gv)
3690 {
3691   CAMLparam1 (gv);
3692   CAMLlocal1 (rv);
3693
3694   guestfs_h *g = Guestfs_val (gv);
3695   if (g == NULL)
3696     caml_failwith ("dmesg: used handle after closing it");
3697
3698   char *r;
3699
3700   caml_enter_blocking_section ();
3701   r = guestfs_dmesg (g);
3702   caml_leave_blocking_section ();
3703   if (r == NULL)
3704     ocaml_guestfs_raise_error (g, "dmesg");
3705
3706   rv = caml_copy_string (r);
3707   free (r);
3708   CAMLreturn (rv);
3709 }
3710
3711 CAMLprim value
3712 ocaml_guestfs_ping_daemon (value gv)
3713 {
3714   CAMLparam1 (gv);
3715   CAMLlocal1 (rv);
3716
3717   guestfs_h *g = Guestfs_val (gv);
3718   if (g == NULL)
3719     caml_failwith ("ping_daemon: used handle after closing it");
3720
3721   int r;
3722
3723   caml_enter_blocking_section ();
3724   r = guestfs_ping_daemon (g);
3725   caml_leave_blocking_section ();
3726   if (r == -1)
3727     ocaml_guestfs_raise_error (g, "ping_daemon");
3728
3729   rv = Val_unit;
3730   CAMLreturn (rv);
3731 }
3732
3733 CAMLprim value
3734 ocaml_guestfs_equal (value gv, value file1v, value file2v)
3735 {
3736   CAMLparam3 (gv, file1v, file2v);
3737   CAMLlocal1 (rv);
3738
3739   guestfs_h *g = Guestfs_val (gv);
3740   if (g == NULL)
3741     caml_failwith ("equal: used handle after closing it");
3742
3743   const char *file1 = String_val (file1v);
3744   const char *file2 = String_val (file2v);
3745   int r;
3746
3747   caml_enter_blocking_section ();
3748   r = guestfs_equal (g, file1, file2);
3749   caml_leave_blocking_section ();
3750   if (r == -1)
3751     ocaml_guestfs_raise_error (g, "equal");
3752
3753   rv = Val_bool (r);
3754   CAMLreturn (rv);
3755 }
3756
3757 CAMLprim value
3758 ocaml_guestfs_strings (value gv, value pathv)
3759 {
3760   CAMLparam2 (gv, pathv);
3761   CAMLlocal1 (rv);
3762
3763   guestfs_h *g = Guestfs_val (gv);
3764   if (g == NULL)
3765     caml_failwith ("strings: used handle after closing it");
3766
3767   const char *path = String_val (pathv);
3768   int i;
3769   char **r;
3770
3771   caml_enter_blocking_section ();
3772   r = guestfs_strings (g, path);
3773   caml_leave_blocking_section ();
3774   if (r == NULL)
3775     ocaml_guestfs_raise_error (g, "strings");
3776
3777   rv = caml_copy_string_array ((const char **) r);
3778   for (i = 0; r[i] != NULL; ++i) free (r[i]);
3779   free (r);
3780   CAMLreturn (rv);
3781 }
3782
3783 CAMLprim value
3784 ocaml_guestfs_strings_e (value gv, value encodingv, value pathv)
3785 {
3786   CAMLparam3 (gv, encodingv, pathv);
3787   CAMLlocal1 (rv);
3788
3789   guestfs_h *g = Guestfs_val (gv);
3790   if (g == NULL)
3791     caml_failwith ("strings_e: used handle after closing it");
3792
3793   const char *encoding = String_val (encodingv);
3794   const char *path = String_val (pathv);
3795   int i;
3796   char **r;
3797
3798   caml_enter_blocking_section ();
3799   r = guestfs_strings_e (g, encoding, path);
3800   caml_leave_blocking_section ();
3801   if (r == NULL)
3802     ocaml_guestfs_raise_error (g, "strings_e");
3803
3804   rv = caml_copy_string_array ((const char **) r);
3805   for (i = 0; r[i] != NULL; ++i) free (r[i]);
3806   free (r);
3807   CAMLreturn (rv);
3808 }
3809
3810 CAMLprim value
3811 ocaml_guestfs_hexdump (value gv, value pathv)
3812 {
3813   CAMLparam2 (gv, pathv);
3814   CAMLlocal1 (rv);
3815
3816   guestfs_h *g = Guestfs_val (gv);
3817   if (g == NULL)
3818     caml_failwith ("hexdump: used handle after closing it");
3819
3820   const char *path = String_val (pathv);
3821   char *r;
3822
3823   caml_enter_blocking_section ();
3824   r = guestfs_hexdump (g, path);
3825   caml_leave_blocking_section ();
3826   if (r == NULL)
3827     ocaml_guestfs_raise_error (g, "hexdump");
3828
3829   rv = caml_copy_string (r);
3830   free (r);
3831   CAMLreturn (rv);
3832 }
3833
3834 CAMLprim value
3835 ocaml_guestfs_zerofree (value gv, value devicev)
3836 {
3837   CAMLparam2 (gv, devicev);
3838   CAMLlocal1 (rv);
3839
3840   guestfs_h *g = Guestfs_val (gv);
3841   if (g == NULL)
3842     caml_failwith ("zerofree: used handle after closing it");
3843
3844   const char *device = String_val (devicev);
3845   int r;
3846
3847   caml_enter_blocking_section ();
3848   r = guestfs_zerofree (g, device);
3849   caml_leave_blocking_section ();
3850   if (r == -1)
3851     ocaml_guestfs_raise_error (g, "zerofree");
3852
3853   rv = Val_unit;
3854   CAMLreturn (rv);
3855 }
3856
3857 CAMLprim value
3858 ocaml_guestfs_pvresize (value gv, value devicev)
3859 {
3860   CAMLparam2 (gv, devicev);
3861   CAMLlocal1 (rv);
3862
3863   guestfs_h *g = Guestfs_val (gv);
3864   if (g == NULL)
3865     caml_failwith ("pvresize: used handle after closing it");
3866
3867   const char *device = String_val (devicev);
3868   int r;
3869
3870   caml_enter_blocking_section ();
3871   r = guestfs_pvresize (g, device);
3872   caml_leave_blocking_section ();
3873   if (r == -1)
3874     ocaml_guestfs_raise_error (g, "pvresize");
3875
3876   rv = Val_unit;
3877   CAMLreturn (rv);
3878 }
3879
3880 CAMLprim value
3881 ocaml_guestfs_sfdisk_N (value gv, value devicev, value nv, value cylsv, value headsv, value sectorsv, value linev)
3882 {
3883   CAMLparam5 (gv, devicev, nv, cylsv, headsv);
3884   CAMLxparam2 (sectorsv, linev);
3885   CAMLlocal1 (rv);
3886
3887   guestfs_h *g = Guestfs_val (gv);
3888   if (g == NULL)
3889     caml_failwith ("sfdisk_N: used handle after closing it");
3890
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);
3897   int r;
3898
3899   caml_enter_blocking_section ();
3900   r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
3901   caml_leave_blocking_section ();
3902   if (r == -1)
3903     ocaml_guestfs_raise_error (g, "sfdisk_N");
3904
3905   rv = Val_unit;
3906   CAMLreturn (rv);
3907 }
3908
3909 CAMLprim value
3910 ocaml_guestfs_sfdisk_N_byte (value *argv, int argn)
3911 {
3912   return ocaml_guestfs_sfdisk_N (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
3913 }
3914
3915 CAMLprim value
3916 ocaml_guestfs_sfdisk_l (value gv, value devicev)
3917 {
3918   CAMLparam2 (gv, devicev);
3919   CAMLlocal1 (rv);
3920
3921   guestfs_h *g = Guestfs_val (gv);
3922   if (g == NULL)
3923     caml_failwith ("sfdisk_l: used handle after closing it");
3924
3925   const char *device = String_val (devicev);
3926   char *r;
3927
3928   caml_enter_blocking_section ();
3929   r = guestfs_sfdisk_l (g, device);
3930   caml_leave_blocking_section ();
3931   if (r == NULL)
3932     ocaml_guestfs_raise_error (g, "sfdisk_l");
3933
3934   rv = caml_copy_string (r);
3935   free (r);
3936   CAMLreturn (rv);
3937 }
3938
3939 CAMLprim value
3940 ocaml_guestfs_sfdisk_kernel_geometry (value gv, value devicev)
3941 {
3942   CAMLparam2 (gv, devicev);
3943   CAMLlocal1 (rv);
3944
3945   guestfs_h *g = Guestfs_val (gv);
3946   if (g == NULL)
3947     caml_failwith ("sfdisk_kernel_geometry: used handle after closing it");
3948
3949   const char *device = String_val (devicev);
3950   char *r;
3951
3952   caml_enter_blocking_section ();
3953   r = guestfs_sfdisk_kernel_geometry (g, device);
3954   caml_leave_blocking_section ();
3955   if (r == NULL)
3956     ocaml_guestfs_raise_error (g, "sfdisk_kernel_geometry");
3957
3958   rv = caml_copy_string (r);
3959   free (r);
3960   CAMLreturn (rv);
3961 }
3962
3963 CAMLprim value
3964 ocaml_guestfs_sfdisk_disk_geometry (value gv, value devicev)
3965 {
3966   CAMLparam2 (gv, devicev);
3967   CAMLlocal1 (rv);
3968
3969   guestfs_h *g = Guestfs_val (gv);
3970   if (g == NULL)
3971     caml_failwith ("sfdisk_disk_geometry: used handle after closing it");
3972
3973   const char *device = String_val (devicev);
3974   char *r;
3975
3976   caml_enter_blocking_section ();
3977   r = guestfs_sfdisk_disk_geometry (g, device);
3978   caml_leave_blocking_section ();
3979   if (r == NULL)
3980     ocaml_guestfs_raise_error (g, "sfdisk_disk_geometry");
3981
3982   rv = caml_copy_string (r);
3983   free (r);
3984   CAMLreturn (rv);
3985 }
3986
3987 CAMLprim value
3988 ocaml_guestfs_vg_activate_all (value gv, value activatev)
3989 {
3990   CAMLparam2 (gv, activatev);
3991   CAMLlocal1 (rv);
3992
3993   guestfs_h *g = Guestfs_val (gv);
3994   if (g == NULL)
3995     caml_failwith ("vg_activate_all: used handle after closing it");
3996
3997   int activate = Bool_val (activatev);
3998   int r;
3999
4000   caml_enter_blocking_section ();
4001   r = guestfs_vg_activate_all (g, activate);
4002   caml_leave_blocking_section ();
4003   if (r == -1)
4004     ocaml_guestfs_raise_error (g, "vg_activate_all");
4005
4006   rv = Val_unit;
4007   CAMLreturn (rv);
4008 }
4009
4010 CAMLprim value
4011 ocaml_guestfs_vg_activate (value gv, value activatev, value volgroupsv)
4012 {
4013   CAMLparam3 (gv, activatev, volgroupsv);
4014   CAMLlocal1 (rv);
4015
4016   guestfs_h *g = Guestfs_val (gv);
4017   if (g == NULL)
4018     caml_failwith ("vg_activate: used handle after closing it");
4019
4020   int activate = Bool_val (activatev);
4021   char **volgroups = ocaml_guestfs_strings_val (g, volgroupsv);
4022   int r;
4023
4024   caml_enter_blocking_section ();
4025   r = guestfs_vg_activate (g, activate, volgroups);
4026   caml_leave_blocking_section ();
4027   ocaml_guestfs_free_strings (volgroups);
4028   if (r == -1)
4029     ocaml_guestfs_raise_error (g, "vg_activate");
4030
4031   rv = Val_unit;
4032   CAMLreturn (rv);
4033 }
4034
4035 CAMLprim value
4036 ocaml_guestfs_lvresize (value gv, value devicev, value mbytesv)
4037 {
4038   CAMLparam3 (gv, devicev, mbytesv);
4039   CAMLlocal1 (rv);
4040
4041   guestfs_h *g = Guestfs_val (gv);
4042   if (g == NULL)
4043     caml_failwith ("lvresize: used handle after closing it");
4044
4045   const char *device = String_val (devicev);
4046   int mbytes = Int_val (mbytesv);
4047   int r;
4048
4049   caml_enter_blocking_section ();
4050   r = guestfs_lvresize (g, device, mbytes);
4051   caml_leave_blocking_section ();
4052   if (r == -1)
4053     ocaml_guestfs_raise_error (g, "lvresize");
4054
4055   rv = Val_unit;
4056   CAMLreturn (rv);
4057 }
4058
4059 CAMLprim value
4060 ocaml_guestfs_resize2fs (value gv, value devicev)
4061 {
4062   CAMLparam2 (gv, devicev);
4063   CAMLlocal1 (rv);
4064
4065   guestfs_h *g = Guestfs_val (gv);
4066   if (g == NULL)
4067     caml_failwith ("resize2fs: used handle after closing it");
4068
4069   const char *device = String_val (devicev);
4070   int r;
4071
4072   caml_enter_blocking_section ();
4073   r = guestfs_resize2fs (g, device);
4074   caml_leave_blocking_section ();
4075   if (r == -1)
4076     ocaml_guestfs_raise_error (g, "resize2fs");
4077
4078   rv = Val_unit;
4079   CAMLreturn (rv);
4080 }
4081
4082 CAMLprim value
4083 ocaml_guestfs_find (value gv, value directoryv)
4084 {
4085   CAMLparam2 (gv, directoryv);
4086   CAMLlocal1 (rv);
4087
4088   guestfs_h *g = Guestfs_val (gv);
4089   if (g == NULL)
4090     caml_failwith ("find: used handle after closing it");
4091
4092   const char *directory = String_val (directoryv);
4093   int i;
4094   char **r;
4095
4096   caml_enter_blocking_section ();
4097   r = guestfs_find (g, directory);
4098   caml_leave_blocking_section ();