More notes in the TODO list.
[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_launch (value gv)
333 {
334   CAMLparam1 (gv);
335   CAMLlocal1 (rv);
336
337   guestfs_h *g = Guestfs_val (gv);
338   if (g == NULL)
339     caml_failwith ("launch: used handle after closing it");
340
341   int r;
342
343   caml_enter_blocking_section ();
344   r = guestfs_launch (g);
345   caml_leave_blocking_section ();
346   if (r == -1)
347     ocaml_guestfs_raise_error (g, "launch");
348
349   rv = Val_unit;
350   CAMLreturn (rv);
351 }
352
353 CAMLprim value
354 ocaml_guestfs_wait_ready (value gv)
355 {
356   CAMLparam1 (gv);
357   CAMLlocal1 (rv);
358
359   guestfs_h *g = Guestfs_val (gv);
360   if (g == NULL)
361     caml_failwith ("wait_ready: used handle after closing it");
362
363   int r;
364
365   caml_enter_blocking_section ();
366   r = guestfs_wait_ready (g);
367   caml_leave_blocking_section ();
368   if (r == -1)
369     ocaml_guestfs_raise_error (g, "wait_ready");
370
371   rv = Val_unit;
372   CAMLreturn (rv);
373 }
374
375 CAMLprim value
376 ocaml_guestfs_kill_subprocess (value gv)
377 {
378   CAMLparam1 (gv);
379   CAMLlocal1 (rv);
380
381   guestfs_h *g = Guestfs_val (gv);
382   if (g == NULL)
383     caml_failwith ("kill_subprocess: used handle after closing it");
384
385   int r;
386
387   caml_enter_blocking_section ();
388   r = guestfs_kill_subprocess (g);
389   caml_leave_blocking_section ();
390   if (r == -1)
391     ocaml_guestfs_raise_error (g, "kill_subprocess");
392
393   rv = Val_unit;
394   CAMLreturn (rv);
395 }
396
397 CAMLprim value
398 ocaml_guestfs_add_drive (value gv, value filenamev)
399 {
400   CAMLparam2 (gv, filenamev);
401   CAMLlocal1 (rv);
402
403   guestfs_h *g = Guestfs_val (gv);
404   if (g == NULL)
405     caml_failwith ("add_drive: used handle after closing it");
406
407   const char *filename = String_val (filenamev);
408   int r;
409
410   caml_enter_blocking_section ();
411   r = guestfs_add_drive (g, filename);
412   caml_leave_blocking_section ();
413   if (r == -1)
414     ocaml_guestfs_raise_error (g, "add_drive");
415
416   rv = Val_unit;
417   CAMLreturn (rv);
418 }
419
420 CAMLprim value
421 ocaml_guestfs_add_cdrom (value gv, value filenamev)
422 {
423   CAMLparam2 (gv, filenamev);
424   CAMLlocal1 (rv);
425
426   guestfs_h *g = Guestfs_val (gv);
427   if (g == NULL)
428     caml_failwith ("add_cdrom: used handle after closing it");
429
430   const char *filename = String_val (filenamev);
431   int r;
432
433   caml_enter_blocking_section ();
434   r = guestfs_add_cdrom (g, filename);
435   caml_leave_blocking_section ();
436   if (r == -1)
437     ocaml_guestfs_raise_error (g, "add_cdrom");
438
439   rv = Val_unit;
440   CAMLreturn (rv);
441 }
442
443 CAMLprim value
444 ocaml_guestfs_config (value gv, value qemuparamv, value qemuvaluev)
445 {
446   CAMLparam3 (gv, qemuparamv, qemuvaluev);
447   CAMLlocal1 (rv);
448
449   guestfs_h *g = Guestfs_val (gv);
450   if (g == NULL)
451     caml_failwith ("config: used handle after closing it");
452
453   const char *qemuparam = String_val (qemuparamv);
454   const char *qemuvalue =
455     qemuvaluev != Val_int (0) ? String_val (Field (qemuvaluev, 0)) : NULL;
456   int r;
457
458   caml_enter_blocking_section ();
459   r = guestfs_config (g, qemuparam, qemuvalue);
460   caml_leave_blocking_section ();
461   if (r == -1)
462     ocaml_guestfs_raise_error (g, "config");
463
464   rv = Val_unit;
465   CAMLreturn (rv);
466 }
467
468 CAMLprim value
469 ocaml_guestfs_set_path (value gv, value pathv)
470 {
471   CAMLparam2 (gv, pathv);
472   CAMLlocal1 (rv);
473
474   guestfs_h *g = Guestfs_val (gv);
475   if (g == NULL)
476     caml_failwith ("set_path: used handle after closing it");
477
478   const char *path = String_val (pathv);
479   int r;
480
481   caml_enter_blocking_section ();
482   r = guestfs_set_path (g, path);
483   caml_leave_blocking_section ();
484   if (r == -1)
485     ocaml_guestfs_raise_error (g, "set_path");
486
487   rv = Val_unit;
488   CAMLreturn (rv);
489 }
490
491 CAMLprim value
492 ocaml_guestfs_get_path (value gv)
493 {
494   CAMLparam1 (gv);
495   CAMLlocal1 (rv);
496
497   guestfs_h *g = Guestfs_val (gv);
498   if (g == NULL)
499     caml_failwith ("get_path: used handle after closing it");
500
501   const char *r;
502
503   caml_enter_blocking_section ();
504   r = guestfs_get_path (g);
505   caml_leave_blocking_section ();
506   if (r == NULL)
507     ocaml_guestfs_raise_error (g, "get_path");
508
509   rv = caml_copy_string (r);
510   CAMLreturn (rv);
511 }
512
513 CAMLprim value
514 ocaml_guestfs_set_autosync (value gv, value autosyncv)
515 {
516   CAMLparam2 (gv, autosyncv);
517   CAMLlocal1 (rv);
518
519   guestfs_h *g = Guestfs_val (gv);
520   if (g == NULL)
521     caml_failwith ("set_autosync: used handle after closing it");
522
523   int autosync = Bool_val (autosyncv);
524   int r;
525
526   caml_enter_blocking_section ();
527   r = guestfs_set_autosync (g, autosync);
528   caml_leave_blocking_section ();
529   if (r == -1)
530     ocaml_guestfs_raise_error (g, "set_autosync");
531
532   rv = Val_unit;
533   CAMLreturn (rv);
534 }
535
536 CAMLprim value
537 ocaml_guestfs_get_autosync (value gv)
538 {
539   CAMLparam1 (gv);
540   CAMLlocal1 (rv);
541
542   guestfs_h *g = Guestfs_val (gv);
543   if (g == NULL)
544     caml_failwith ("get_autosync: used handle after closing it");
545
546   int r;
547
548   caml_enter_blocking_section ();
549   r = guestfs_get_autosync (g);
550   caml_leave_blocking_section ();
551   if (r == -1)
552     ocaml_guestfs_raise_error (g, "get_autosync");
553
554   rv = Val_bool (r);
555   CAMLreturn (rv);
556 }
557
558 CAMLprim value
559 ocaml_guestfs_set_verbose (value gv, value verbosev)
560 {
561   CAMLparam2 (gv, verbosev);
562   CAMLlocal1 (rv);
563
564   guestfs_h *g = Guestfs_val (gv);
565   if (g == NULL)
566     caml_failwith ("set_verbose: used handle after closing it");
567
568   int verbose = Bool_val (verbosev);
569   int r;
570
571   caml_enter_blocking_section ();
572   r = guestfs_set_verbose (g, verbose);
573   caml_leave_blocking_section ();
574   if (r == -1)
575     ocaml_guestfs_raise_error (g, "set_verbose");
576
577   rv = Val_unit;
578   CAMLreturn (rv);
579 }
580
581 CAMLprim value
582 ocaml_guestfs_get_verbose (value gv)
583 {
584   CAMLparam1 (gv);
585   CAMLlocal1 (rv);
586
587   guestfs_h *g = Guestfs_val (gv);
588   if (g == NULL)
589     caml_failwith ("get_verbose: used handle after closing it");
590
591   int r;
592
593   caml_enter_blocking_section ();
594   r = guestfs_get_verbose (g);
595   caml_leave_blocking_section ();
596   if (r == -1)
597     ocaml_guestfs_raise_error (g, "get_verbose");
598
599   rv = Val_bool (r);
600   CAMLreturn (rv);
601 }
602
603 CAMLprim value
604 ocaml_guestfs_is_ready (value gv)
605 {
606   CAMLparam1 (gv);
607   CAMLlocal1 (rv);
608
609   guestfs_h *g = Guestfs_val (gv);
610   if (g == NULL)
611     caml_failwith ("is_ready: used handle after closing it");
612
613   int r;
614
615   caml_enter_blocking_section ();
616   r = guestfs_is_ready (g);
617   caml_leave_blocking_section ();
618   if (r == -1)
619     ocaml_guestfs_raise_error (g, "is_ready");
620
621   rv = Val_bool (r);
622   CAMLreturn (rv);
623 }
624
625 CAMLprim value
626 ocaml_guestfs_is_config (value gv)
627 {
628   CAMLparam1 (gv);
629   CAMLlocal1 (rv);
630
631   guestfs_h *g = Guestfs_val (gv);
632   if (g == NULL)
633     caml_failwith ("is_config: used handle after closing it");
634
635   int r;
636
637   caml_enter_blocking_section ();
638   r = guestfs_is_config (g);
639   caml_leave_blocking_section ();
640   if (r == -1)
641     ocaml_guestfs_raise_error (g, "is_config");
642
643   rv = Val_bool (r);
644   CAMLreturn (rv);
645 }
646
647 CAMLprim value
648 ocaml_guestfs_is_launching (value gv)
649 {
650   CAMLparam1 (gv);
651   CAMLlocal1 (rv);
652
653   guestfs_h *g = Guestfs_val (gv);
654   if (g == NULL)
655     caml_failwith ("is_launching: used handle after closing it");
656
657   int r;
658
659   caml_enter_blocking_section ();
660   r = guestfs_is_launching (g);
661   caml_leave_blocking_section ();
662   if (r == -1)
663     ocaml_guestfs_raise_error (g, "is_launching");
664
665   rv = Val_bool (r);
666   CAMLreturn (rv);
667 }
668
669 CAMLprim value
670 ocaml_guestfs_is_busy (value gv)
671 {
672   CAMLparam1 (gv);
673   CAMLlocal1 (rv);
674
675   guestfs_h *g = Guestfs_val (gv);
676   if (g == NULL)
677     caml_failwith ("is_busy: used handle after closing it");
678
679   int r;
680
681   caml_enter_blocking_section ();
682   r = guestfs_is_busy (g);
683   caml_leave_blocking_section ();
684   if (r == -1)
685     ocaml_guestfs_raise_error (g, "is_busy");
686
687   rv = Val_bool (r);
688   CAMLreturn (rv);
689 }
690
691 CAMLprim value
692 ocaml_guestfs_get_state (value gv)
693 {
694   CAMLparam1 (gv);
695   CAMLlocal1 (rv);
696
697   guestfs_h *g = Guestfs_val (gv);
698   if (g == NULL)
699     caml_failwith ("get_state: used handle after closing it");
700
701   int r;
702
703   caml_enter_blocking_section ();
704   r = guestfs_get_state (g);
705   caml_leave_blocking_section ();
706   if (r == -1)
707     ocaml_guestfs_raise_error (g, "get_state");
708
709   rv = Val_int (r);
710   CAMLreturn (rv);
711 }
712
713 CAMLprim value
714 ocaml_guestfs_set_busy (value gv)
715 {
716   CAMLparam1 (gv);
717   CAMLlocal1 (rv);
718
719   guestfs_h *g = Guestfs_val (gv);
720   if (g == NULL)
721     caml_failwith ("set_busy: used handle after closing it");
722
723   int r;
724
725   caml_enter_blocking_section ();
726   r = guestfs_set_busy (g);
727   caml_leave_blocking_section ();
728   if (r == -1)
729     ocaml_guestfs_raise_error (g, "set_busy");
730
731   rv = Val_unit;
732   CAMLreturn (rv);
733 }
734
735 CAMLprim value
736 ocaml_guestfs_set_ready (value gv)
737 {
738   CAMLparam1 (gv);
739   CAMLlocal1 (rv);
740
741   guestfs_h *g = Guestfs_val (gv);
742   if (g == NULL)
743     caml_failwith ("set_ready: used handle after closing it");
744
745   int r;
746
747   caml_enter_blocking_section ();
748   r = guestfs_set_ready (g);
749   caml_leave_blocking_section ();
750   if (r == -1)
751     ocaml_guestfs_raise_error (g, "set_ready");
752
753   rv = Val_unit;
754   CAMLreturn (rv);
755 }
756
757 CAMLprim value
758 ocaml_guestfs_mount (value gv, value devicev, value mountpointv)
759 {
760   CAMLparam3 (gv, devicev, mountpointv);
761   CAMLlocal1 (rv);
762
763   guestfs_h *g = Guestfs_val (gv);
764   if (g == NULL)
765     caml_failwith ("mount: used handle after closing it");
766
767   const char *device = String_val (devicev);
768   const char *mountpoint = String_val (mountpointv);
769   int r;
770
771   caml_enter_blocking_section ();
772   r = guestfs_mount (g, device, mountpoint);
773   caml_leave_blocking_section ();
774   if (r == -1)
775     ocaml_guestfs_raise_error (g, "mount");
776
777   rv = Val_unit;
778   CAMLreturn (rv);
779 }
780
781 CAMLprim value
782 ocaml_guestfs_sync (value gv)
783 {
784   CAMLparam1 (gv);
785   CAMLlocal1 (rv);
786
787   guestfs_h *g = Guestfs_val (gv);
788   if (g == NULL)
789     caml_failwith ("sync: used handle after closing it");
790
791   int r;
792
793   caml_enter_blocking_section ();
794   r = guestfs_sync (g);
795   caml_leave_blocking_section ();
796   if (r == -1)
797     ocaml_guestfs_raise_error (g, "sync");
798
799   rv = Val_unit;
800   CAMLreturn (rv);
801 }
802
803 CAMLprim value
804 ocaml_guestfs_touch (value gv, value pathv)
805 {
806   CAMLparam2 (gv, pathv);
807   CAMLlocal1 (rv);
808
809   guestfs_h *g = Guestfs_val (gv);
810   if (g == NULL)
811     caml_failwith ("touch: used handle after closing it");
812
813   const char *path = String_val (pathv);
814   int r;
815
816   caml_enter_blocking_section ();
817   r = guestfs_touch (g, path);
818   caml_leave_blocking_section ();
819   if (r == -1)
820     ocaml_guestfs_raise_error (g, "touch");
821
822   rv = Val_unit;
823   CAMLreturn (rv);
824 }
825
826 CAMLprim value
827 ocaml_guestfs_cat (value gv, value pathv)
828 {
829   CAMLparam2 (gv, pathv);
830   CAMLlocal1 (rv);
831
832   guestfs_h *g = Guestfs_val (gv);
833   if (g == NULL)
834     caml_failwith ("cat: used handle after closing it");
835
836   const char *path = String_val (pathv);
837   char *r;
838
839   caml_enter_blocking_section ();
840   r = guestfs_cat (g, path);
841   caml_leave_blocking_section ();
842   if (r == NULL)
843     ocaml_guestfs_raise_error (g, "cat");
844
845   rv = caml_copy_string (r);
846   free (r);
847   CAMLreturn (rv);
848 }
849
850 CAMLprim value
851 ocaml_guestfs_ll (value gv, value directoryv)
852 {
853   CAMLparam2 (gv, directoryv);
854   CAMLlocal1 (rv);
855
856   guestfs_h *g = Guestfs_val (gv);
857   if (g == NULL)
858     caml_failwith ("ll: used handle after closing it");
859
860   const char *directory = String_val (directoryv);
861   char *r;
862
863   caml_enter_blocking_section ();
864   r = guestfs_ll (g, directory);
865   caml_leave_blocking_section ();
866   if (r == NULL)
867     ocaml_guestfs_raise_error (g, "ll");
868
869   rv = caml_copy_string (r);
870   free (r);
871   CAMLreturn (rv);
872 }
873
874 CAMLprim value
875 ocaml_guestfs_ls (value gv, value directoryv)
876 {
877   CAMLparam2 (gv, directoryv);
878   CAMLlocal1 (rv);
879
880   guestfs_h *g = Guestfs_val (gv);
881   if (g == NULL)
882     caml_failwith ("ls: used handle after closing it");
883
884   const char *directory = String_val (directoryv);
885   int i;
886   char **r;
887
888   caml_enter_blocking_section ();
889   r = guestfs_ls (g, directory);
890   caml_leave_blocking_section ();
891   if (r == NULL)
892     ocaml_guestfs_raise_error (g, "ls");
893
894   rv = caml_copy_string_array ((const char **) r);
895   for (i = 0; r[i] != NULL; ++i) free (r[i]);
896   free (r);
897   CAMLreturn (rv);
898 }
899
900 CAMLprim value
901 ocaml_guestfs_list_devices (value gv)
902 {
903   CAMLparam1 (gv);
904   CAMLlocal1 (rv);
905
906   guestfs_h *g = Guestfs_val (gv);
907   if (g == NULL)
908     caml_failwith ("list_devices: used handle after closing it");
909
910   int i;
911   char **r;
912
913   caml_enter_blocking_section ();
914   r = guestfs_list_devices (g);
915   caml_leave_blocking_section ();
916   if (r == NULL)
917     ocaml_guestfs_raise_error (g, "list_devices");
918
919   rv = caml_copy_string_array ((const char **) r);
920   for (i = 0; r[i] != NULL; ++i) free (r[i]);
921   free (r);
922   CAMLreturn (rv);
923 }
924
925 CAMLprim value
926 ocaml_guestfs_list_partitions (value gv)
927 {
928   CAMLparam1 (gv);
929   CAMLlocal1 (rv);
930
931   guestfs_h *g = Guestfs_val (gv);
932   if (g == NULL)
933     caml_failwith ("list_partitions: used handle after closing it");
934
935   int i;
936   char **r;
937
938   caml_enter_blocking_section ();
939   r = guestfs_list_partitions (g);
940   caml_leave_blocking_section ();
941   if (r == NULL)
942     ocaml_guestfs_raise_error (g, "list_partitions");
943
944   rv = caml_copy_string_array ((const char **) r);
945   for (i = 0; r[i] != NULL; ++i) free (r[i]);
946   free (r);
947   CAMLreturn (rv);
948 }
949
950 CAMLprim value
951 ocaml_guestfs_pvs (value gv)
952 {
953   CAMLparam1 (gv);
954   CAMLlocal1 (rv);
955
956   guestfs_h *g = Guestfs_val (gv);
957   if (g == NULL)
958     caml_failwith ("pvs: used handle after closing it");
959
960   int i;
961   char **r;
962
963   caml_enter_blocking_section ();
964   r = guestfs_pvs (g);
965   caml_leave_blocking_section ();
966   if (r == NULL)
967     ocaml_guestfs_raise_error (g, "pvs");
968
969   rv = caml_copy_string_array ((const char **) r);
970   for (i = 0; r[i] != NULL; ++i) free (r[i]);
971   free (r);
972   CAMLreturn (rv);
973 }
974
975 CAMLprim value
976 ocaml_guestfs_vgs (value gv)
977 {
978   CAMLparam1 (gv);
979   CAMLlocal1 (rv);
980
981   guestfs_h *g = Guestfs_val (gv);
982   if (g == NULL)
983     caml_failwith ("vgs: used handle after closing it");
984
985   int i;
986   char **r;
987
988   caml_enter_blocking_section ();
989   r = guestfs_vgs (g);
990   caml_leave_blocking_section ();
991   if (r == NULL)
992     ocaml_guestfs_raise_error (g, "vgs");
993
994   rv = caml_copy_string_array ((const char **) r);
995   for (i = 0; r[i] != NULL; ++i) free (r[i]);
996   free (r);
997   CAMLreturn (rv);
998 }
999
1000 CAMLprim value
1001 ocaml_guestfs_lvs (value gv)
1002 {
1003   CAMLparam1 (gv);
1004   CAMLlocal1 (rv);
1005
1006   guestfs_h *g = Guestfs_val (gv);
1007   if (g == NULL)
1008     caml_failwith ("lvs: used handle after closing it");
1009
1010   int i;
1011   char **r;
1012
1013   caml_enter_blocking_section ();
1014   r = guestfs_lvs (g);
1015   caml_leave_blocking_section ();
1016   if (r == NULL)
1017     ocaml_guestfs_raise_error (g, "lvs");
1018
1019   rv = caml_copy_string_array ((const char **) r);
1020   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1021   free (r);
1022   CAMLreturn (rv);
1023 }
1024
1025 CAMLprim value
1026 ocaml_guestfs_pvs_full (value gv)
1027 {
1028   CAMLparam1 (gv);
1029   CAMLlocal1 (rv);
1030
1031   guestfs_h *g = Guestfs_val (gv);
1032   if (g == NULL)
1033     caml_failwith ("pvs_full: used handle after closing it");
1034
1035   struct guestfs_lvm_pv_list *r;
1036
1037   caml_enter_blocking_section ();
1038   r = guestfs_pvs_full (g);
1039   caml_leave_blocking_section ();
1040   if (r == NULL)
1041     ocaml_guestfs_raise_error (g, "pvs_full");
1042
1043   rv = copy_lvm_pv_list (r);
1044   guestfs_free_lvm_pv_list (r);
1045   CAMLreturn (rv);
1046 }
1047
1048 CAMLprim value
1049 ocaml_guestfs_vgs_full (value gv)
1050 {
1051   CAMLparam1 (gv);
1052   CAMLlocal1 (rv);
1053
1054   guestfs_h *g = Guestfs_val (gv);
1055   if (g == NULL)
1056     caml_failwith ("vgs_full: used handle after closing it");
1057
1058   struct guestfs_lvm_vg_list *r;
1059
1060   caml_enter_blocking_section ();
1061   r = guestfs_vgs_full (g);
1062   caml_leave_blocking_section ();
1063   if (r == NULL)
1064     ocaml_guestfs_raise_error (g, "vgs_full");
1065
1066   rv = copy_lvm_vg_list (r);
1067   guestfs_free_lvm_vg_list (r);
1068   CAMLreturn (rv);
1069 }
1070
1071 CAMLprim value
1072 ocaml_guestfs_lvs_full (value gv)
1073 {
1074   CAMLparam1 (gv);
1075   CAMLlocal1 (rv);
1076
1077   guestfs_h *g = Guestfs_val (gv);
1078   if (g == NULL)
1079     caml_failwith ("lvs_full: used handle after closing it");
1080
1081   struct guestfs_lvm_lv_list *r;
1082
1083   caml_enter_blocking_section ();
1084   r = guestfs_lvs_full (g);
1085   caml_leave_blocking_section ();
1086   if (r == NULL)
1087     ocaml_guestfs_raise_error (g, "lvs_full");
1088
1089   rv = copy_lvm_lv_list (r);
1090   guestfs_free_lvm_lv_list (r);
1091   CAMLreturn (rv);
1092 }
1093
1094 CAMLprim value
1095 ocaml_guestfs_read_lines (value gv, value pathv)
1096 {
1097   CAMLparam2 (gv, pathv);
1098   CAMLlocal1 (rv);
1099
1100   guestfs_h *g = Guestfs_val (gv);
1101   if (g == NULL)
1102     caml_failwith ("read_lines: used handle after closing it");
1103
1104   const char *path = String_val (pathv);
1105   int i;
1106   char **r;
1107
1108   caml_enter_blocking_section ();
1109   r = guestfs_read_lines (g, path);
1110   caml_leave_blocking_section ();
1111   if (r == NULL)
1112     ocaml_guestfs_raise_error (g, "read_lines");
1113
1114   rv = caml_copy_string_array ((const char **) r);
1115   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1116   free (r);
1117   CAMLreturn (rv);
1118 }
1119
1120 CAMLprim value
1121 ocaml_guestfs_aug_init (value gv, value rootv, value flagsv)
1122 {
1123   CAMLparam3 (gv, rootv, flagsv);
1124   CAMLlocal1 (rv);
1125
1126   guestfs_h *g = Guestfs_val (gv);
1127   if (g == NULL)
1128     caml_failwith ("aug_init: used handle after closing it");
1129
1130   const char *root = String_val (rootv);
1131   int flags = Int_val (flagsv);
1132   int r;
1133
1134   caml_enter_blocking_section ();
1135   r = guestfs_aug_init (g, root, flags);
1136   caml_leave_blocking_section ();
1137   if (r == -1)
1138     ocaml_guestfs_raise_error (g, "aug_init");
1139
1140   rv = Val_unit;
1141   CAMLreturn (rv);
1142 }
1143
1144 CAMLprim value
1145 ocaml_guestfs_aug_close (value gv)
1146 {
1147   CAMLparam1 (gv);
1148   CAMLlocal1 (rv);
1149
1150   guestfs_h *g = Guestfs_val (gv);
1151   if (g == NULL)
1152     caml_failwith ("aug_close: used handle after closing it");
1153
1154   int r;
1155
1156   caml_enter_blocking_section ();
1157   r = guestfs_aug_close (g);
1158   caml_leave_blocking_section ();
1159   if (r == -1)
1160     ocaml_guestfs_raise_error (g, "aug_close");
1161
1162   rv = Val_unit;
1163   CAMLreturn (rv);
1164 }
1165
1166 CAMLprim value
1167 ocaml_guestfs_aug_defvar (value gv, value namev, value exprv)
1168 {
1169   CAMLparam3 (gv, namev, exprv);
1170   CAMLlocal1 (rv);
1171
1172   guestfs_h *g = Guestfs_val (gv);
1173   if (g == NULL)
1174     caml_failwith ("aug_defvar: used handle after closing it");
1175
1176   const char *name = String_val (namev);
1177   const char *expr =
1178     exprv != Val_int (0) ? String_val (Field (exprv, 0)) : NULL;
1179   int r;
1180
1181   caml_enter_blocking_section ();
1182   r = guestfs_aug_defvar (g, name, expr);
1183   caml_leave_blocking_section ();
1184   if (r == -1)
1185     ocaml_guestfs_raise_error (g, "aug_defvar");
1186
1187   rv = Val_int (r);
1188   CAMLreturn (rv);
1189 }
1190
1191 CAMLprim value
1192 ocaml_guestfs_aug_defnode (value gv, value namev, value exprv, value valv)
1193 {
1194   CAMLparam4 (gv, namev, exprv, valv);
1195   CAMLlocal1 (rv);
1196
1197   guestfs_h *g = Guestfs_val (gv);
1198   if (g == NULL)
1199     caml_failwith ("aug_defnode: used handle after closing it");
1200
1201   const char *name = String_val (namev);
1202   const char *expr = String_val (exprv);
1203   const char *val = String_val (valv);
1204   struct guestfs_int_bool *r;
1205
1206   caml_enter_blocking_section ();
1207   r = guestfs_aug_defnode (g, name, expr, val);
1208   caml_leave_blocking_section ();
1209   if (r == NULL)
1210     ocaml_guestfs_raise_error (g, "aug_defnode");
1211
1212   rv = caml_alloc (2, 0);
1213   Store_field (rv, 0, Val_int (r->i));
1214   Store_field (rv, 1, Val_bool (r->b));
1215   guestfs_free_int_bool (r);
1216   CAMLreturn (rv);
1217 }
1218
1219 CAMLprim value
1220 ocaml_guestfs_aug_get (value gv, value pathv)
1221 {
1222   CAMLparam2 (gv, pathv);
1223   CAMLlocal1 (rv);
1224
1225   guestfs_h *g = Guestfs_val (gv);
1226   if (g == NULL)
1227     caml_failwith ("aug_get: used handle after closing it");
1228
1229   const char *path = String_val (pathv);
1230   char *r;
1231
1232   caml_enter_blocking_section ();
1233   r = guestfs_aug_get (g, path);
1234   caml_leave_blocking_section ();
1235   if (r == NULL)
1236     ocaml_guestfs_raise_error (g, "aug_get");
1237
1238   rv = caml_copy_string (r);
1239   free (r);
1240   CAMLreturn (rv);
1241 }
1242
1243 CAMLprim value
1244 ocaml_guestfs_aug_set (value gv, value pathv, value valv)
1245 {
1246   CAMLparam3 (gv, pathv, valv);
1247   CAMLlocal1 (rv);
1248
1249   guestfs_h *g = Guestfs_val (gv);
1250   if (g == NULL)
1251     caml_failwith ("aug_set: used handle after closing it");
1252
1253   const char *path = String_val (pathv);
1254   const char *val = String_val (valv);
1255   int r;
1256
1257   caml_enter_blocking_section ();
1258   r = guestfs_aug_set (g, path, val);
1259   caml_leave_blocking_section ();
1260   if (r == -1)
1261     ocaml_guestfs_raise_error (g, "aug_set");
1262
1263   rv = Val_unit;
1264   CAMLreturn (rv);
1265 }
1266
1267 CAMLprim value
1268 ocaml_guestfs_aug_insert (value gv, value pathv, value labelv, value beforev)
1269 {
1270   CAMLparam4 (gv, pathv, labelv, beforev);
1271   CAMLlocal1 (rv);
1272
1273   guestfs_h *g = Guestfs_val (gv);
1274   if (g == NULL)
1275     caml_failwith ("aug_insert: used handle after closing it");
1276
1277   const char *path = String_val (pathv);
1278   const char *label = String_val (labelv);
1279   int before = Bool_val (beforev);
1280   int r;
1281
1282   caml_enter_blocking_section ();
1283   r = guestfs_aug_insert (g, path, label, before);
1284   caml_leave_blocking_section ();
1285   if (r == -1)
1286     ocaml_guestfs_raise_error (g, "aug_insert");
1287
1288   rv = Val_unit;
1289   CAMLreturn (rv);
1290 }
1291
1292 CAMLprim value
1293 ocaml_guestfs_aug_rm (value gv, value pathv)
1294 {
1295   CAMLparam2 (gv, pathv);
1296   CAMLlocal1 (rv);
1297
1298   guestfs_h *g = Guestfs_val (gv);
1299   if (g == NULL)
1300     caml_failwith ("aug_rm: used handle after closing it");
1301
1302   const char *path = String_val (pathv);
1303   int r;
1304
1305   caml_enter_blocking_section ();
1306   r = guestfs_aug_rm (g, path);
1307   caml_leave_blocking_section ();
1308   if (r == -1)
1309     ocaml_guestfs_raise_error (g, "aug_rm");
1310
1311   rv = Val_int (r);
1312   CAMLreturn (rv);
1313 }
1314
1315 CAMLprim value
1316 ocaml_guestfs_aug_mv (value gv, value srcv, value destv)
1317 {
1318   CAMLparam3 (gv, srcv, destv);
1319   CAMLlocal1 (rv);
1320
1321   guestfs_h *g = Guestfs_val (gv);
1322   if (g == NULL)
1323     caml_failwith ("aug_mv: used handle after closing it");
1324
1325   const char *src = String_val (srcv);
1326   const char *dest = String_val (destv);
1327   int r;
1328
1329   caml_enter_blocking_section ();
1330   r = guestfs_aug_mv (g, src, dest);
1331   caml_leave_blocking_section ();
1332   if (r == -1)
1333     ocaml_guestfs_raise_error (g, "aug_mv");
1334
1335   rv = Val_unit;
1336   CAMLreturn (rv);
1337 }
1338
1339 CAMLprim value
1340 ocaml_guestfs_aug_match (value gv, value pathv)
1341 {
1342   CAMLparam2 (gv, pathv);
1343   CAMLlocal1 (rv);
1344
1345   guestfs_h *g = Guestfs_val (gv);
1346   if (g == NULL)
1347     caml_failwith ("aug_match: used handle after closing it");
1348
1349   const char *path = String_val (pathv);
1350   int i;
1351   char **r;
1352
1353   caml_enter_blocking_section ();
1354   r = guestfs_aug_match (g, path);
1355   caml_leave_blocking_section ();
1356   if (r == NULL)
1357     ocaml_guestfs_raise_error (g, "aug_match");
1358
1359   rv = caml_copy_string_array ((const char **) r);
1360   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1361   free (r);
1362   CAMLreturn (rv);
1363 }
1364
1365 CAMLprim value
1366 ocaml_guestfs_aug_save (value gv)
1367 {
1368   CAMLparam1 (gv);
1369   CAMLlocal1 (rv);
1370
1371   guestfs_h *g = Guestfs_val (gv);
1372   if (g == NULL)
1373     caml_failwith ("aug_save: used handle after closing it");
1374
1375   int r;
1376
1377   caml_enter_blocking_section ();
1378   r = guestfs_aug_save (g);
1379   caml_leave_blocking_section ();
1380   if (r == -1)
1381     ocaml_guestfs_raise_error (g, "aug_save");
1382
1383   rv = Val_unit;
1384   CAMLreturn (rv);
1385 }
1386
1387 CAMLprim value
1388 ocaml_guestfs_aug_load (value gv)
1389 {
1390   CAMLparam1 (gv);
1391   CAMLlocal1 (rv);
1392
1393   guestfs_h *g = Guestfs_val (gv);
1394   if (g == NULL)
1395     caml_failwith ("aug_load: used handle after closing it");
1396
1397   int r;
1398
1399   caml_enter_blocking_section ();
1400   r = guestfs_aug_load (g);
1401   caml_leave_blocking_section ();
1402   if (r == -1)
1403     ocaml_guestfs_raise_error (g, "aug_load");
1404
1405   rv = Val_unit;
1406   CAMLreturn (rv);
1407 }
1408
1409 CAMLprim value
1410 ocaml_guestfs_aug_ls (value gv, value pathv)
1411 {
1412   CAMLparam2 (gv, pathv);
1413   CAMLlocal1 (rv);
1414
1415   guestfs_h *g = Guestfs_val (gv);
1416   if (g == NULL)
1417     caml_failwith ("aug_ls: used handle after closing it");
1418
1419   const char *path = String_val (pathv);
1420   int i;
1421   char **r;
1422
1423   caml_enter_blocking_section ();
1424   r = guestfs_aug_ls (g, path);
1425   caml_leave_blocking_section ();
1426   if (r == NULL)
1427     ocaml_guestfs_raise_error (g, "aug_ls");
1428
1429   rv = caml_copy_string_array ((const char **) r);
1430   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1431   free (r);
1432   CAMLreturn (rv);
1433 }
1434
1435 CAMLprim value
1436 ocaml_guestfs_rm (value gv, value pathv)
1437 {
1438   CAMLparam2 (gv, pathv);
1439   CAMLlocal1 (rv);
1440
1441   guestfs_h *g = Guestfs_val (gv);
1442   if (g == NULL)
1443     caml_failwith ("rm: used handle after closing it");
1444
1445   const char *path = String_val (pathv);
1446   int r;
1447
1448   caml_enter_blocking_section ();
1449   r = guestfs_rm (g, path);
1450   caml_leave_blocking_section ();
1451   if (r == -1)
1452     ocaml_guestfs_raise_error (g, "rm");
1453
1454   rv = Val_unit;
1455   CAMLreturn (rv);
1456 }
1457
1458 CAMLprim value
1459 ocaml_guestfs_rmdir (value gv, value pathv)
1460 {
1461   CAMLparam2 (gv, pathv);
1462   CAMLlocal1 (rv);
1463
1464   guestfs_h *g = Guestfs_val (gv);
1465   if (g == NULL)
1466     caml_failwith ("rmdir: used handle after closing it");
1467
1468   const char *path = String_val (pathv);
1469   int r;
1470
1471   caml_enter_blocking_section ();
1472   r = guestfs_rmdir (g, path);
1473   caml_leave_blocking_section ();
1474   if (r == -1)
1475     ocaml_guestfs_raise_error (g, "rmdir");
1476
1477   rv = Val_unit;
1478   CAMLreturn (rv);
1479 }
1480
1481 CAMLprim value
1482 ocaml_guestfs_rm_rf (value gv, value pathv)
1483 {
1484   CAMLparam2 (gv, pathv);
1485   CAMLlocal1 (rv);
1486
1487   guestfs_h *g = Guestfs_val (gv);
1488   if (g == NULL)
1489     caml_failwith ("rm_rf: used handle after closing it");
1490
1491   const char *path = String_val (pathv);
1492   int r;
1493
1494   caml_enter_blocking_section ();
1495   r = guestfs_rm_rf (g, path);
1496   caml_leave_blocking_section ();
1497   if (r == -1)
1498     ocaml_guestfs_raise_error (g, "rm_rf");
1499
1500   rv = Val_unit;
1501   CAMLreturn (rv);
1502 }
1503
1504 CAMLprim value
1505 ocaml_guestfs_mkdir (value gv, value pathv)
1506 {
1507   CAMLparam2 (gv, pathv);
1508   CAMLlocal1 (rv);
1509
1510   guestfs_h *g = Guestfs_val (gv);
1511   if (g == NULL)
1512     caml_failwith ("mkdir: used handle after closing it");
1513
1514   const char *path = String_val (pathv);
1515   int r;
1516
1517   caml_enter_blocking_section ();
1518   r = guestfs_mkdir (g, path);
1519   caml_leave_blocking_section ();
1520   if (r == -1)
1521     ocaml_guestfs_raise_error (g, "mkdir");
1522
1523   rv = Val_unit;
1524   CAMLreturn (rv);
1525 }
1526
1527 CAMLprim value
1528 ocaml_guestfs_mkdir_p (value gv, value pathv)
1529 {
1530   CAMLparam2 (gv, pathv);
1531   CAMLlocal1 (rv);
1532
1533   guestfs_h *g = Guestfs_val (gv);
1534   if (g == NULL)
1535     caml_failwith ("mkdir_p: used handle after closing it");
1536
1537   const char *path = String_val (pathv);
1538   int r;
1539
1540   caml_enter_blocking_section ();
1541   r = guestfs_mkdir_p (g, path);
1542   caml_leave_blocking_section ();
1543   if (r == -1)
1544     ocaml_guestfs_raise_error (g, "mkdir_p");
1545
1546   rv = Val_unit;
1547   CAMLreturn (rv);
1548 }
1549
1550 CAMLprim value
1551 ocaml_guestfs_chmod (value gv, value modev, value pathv)
1552 {
1553   CAMLparam3 (gv, modev, pathv);
1554   CAMLlocal1 (rv);
1555
1556   guestfs_h *g = Guestfs_val (gv);
1557   if (g == NULL)
1558     caml_failwith ("chmod: used handle after closing it");
1559
1560   int mode = Int_val (modev);
1561   const char *path = String_val (pathv);
1562   int r;
1563
1564   caml_enter_blocking_section ();
1565   r = guestfs_chmod (g, mode, path);
1566   caml_leave_blocking_section ();
1567   if (r == -1)
1568     ocaml_guestfs_raise_error (g, "chmod");
1569
1570   rv = Val_unit;
1571   CAMLreturn (rv);
1572 }
1573
1574 CAMLprim value
1575 ocaml_guestfs_chown (value gv, value ownerv, value groupv, value pathv)
1576 {
1577   CAMLparam4 (gv, ownerv, groupv, pathv);
1578   CAMLlocal1 (rv);
1579
1580   guestfs_h *g = Guestfs_val (gv);
1581   if (g == NULL)
1582     caml_failwith ("chown: used handle after closing it");
1583
1584   int owner = Int_val (ownerv);
1585   int group = Int_val (groupv);
1586   const char *path = String_val (pathv);
1587   int r;
1588
1589   caml_enter_blocking_section ();
1590   r = guestfs_chown (g, owner, group, path);
1591   caml_leave_blocking_section ();
1592   if (r == -1)
1593     ocaml_guestfs_raise_error (g, "chown");
1594
1595   rv = Val_unit;
1596   CAMLreturn (rv);
1597 }
1598
1599 CAMLprim value
1600 ocaml_guestfs_exists (value gv, value pathv)
1601 {
1602   CAMLparam2 (gv, pathv);
1603   CAMLlocal1 (rv);
1604
1605   guestfs_h *g = Guestfs_val (gv);
1606   if (g == NULL)
1607     caml_failwith ("exists: used handle after closing it");
1608
1609   const char *path = String_val (pathv);
1610   int r;
1611
1612   caml_enter_blocking_section ();
1613   r = guestfs_exists (g, path);
1614   caml_leave_blocking_section ();
1615   if (r == -1)
1616     ocaml_guestfs_raise_error (g, "exists");
1617
1618   rv = Val_bool (r);
1619   CAMLreturn (rv);
1620 }
1621
1622 CAMLprim value
1623 ocaml_guestfs_is_file (value gv, value pathv)
1624 {
1625   CAMLparam2 (gv, pathv);
1626   CAMLlocal1 (rv);
1627
1628   guestfs_h *g = Guestfs_val (gv);
1629   if (g == NULL)
1630     caml_failwith ("is_file: used handle after closing it");
1631
1632   const char *path = String_val (pathv);
1633   int r;
1634
1635   caml_enter_blocking_section ();
1636   r = guestfs_is_file (g, path);
1637   caml_leave_blocking_section ();
1638   if (r == -1)
1639     ocaml_guestfs_raise_error (g, "is_file");
1640
1641   rv = Val_bool (r);
1642   CAMLreturn (rv);
1643 }
1644
1645 CAMLprim value
1646 ocaml_guestfs_is_dir (value gv, value pathv)
1647 {
1648   CAMLparam2 (gv, pathv);
1649   CAMLlocal1 (rv);
1650
1651   guestfs_h *g = Guestfs_val (gv);
1652   if (g == NULL)
1653     caml_failwith ("is_dir: used handle after closing it");
1654
1655   const char *path = String_val (pathv);
1656   int r;
1657
1658   caml_enter_blocking_section ();
1659   r = guestfs_is_dir (g, path);
1660   caml_leave_blocking_section ();
1661   if (r == -1)
1662     ocaml_guestfs_raise_error (g, "is_dir");
1663
1664   rv = Val_bool (r);
1665   CAMLreturn (rv);
1666 }
1667
1668 CAMLprim value
1669 ocaml_guestfs_pvcreate (value gv, value devicev)
1670 {
1671   CAMLparam2 (gv, devicev);
1672   CAMLlocal1 (rv);
1673
1674   guestfs_h *g = Guestfs_val (gv);
1675   if (g == NULL)
1676     caml_failwith ("pvcreate: used handle after closing it");
1677
1678   const char *device = String_val (devicev);
1679   int r;
1680
1681   caml_enter_blocking_section ();
1682   r = guestfs_pvcreate (g, device);
1683   caml_leave_blocking_section ();
1684   if (r == -1)
1685     ocaml_guestfs_raise_error (g, "pvcreate");
1686
1687   rv = Val_unit;
1688   CAMLreturn (rv);
1689 }
1690
1691 CAMLprim value
1692 ocaml_guestfs_vgcreate (value gv, value volgroupv, value physvolsv)
1693 {
1694   CAMLparam3 (gv, volgroupv, physvolsv);
1695   CAMLlocal1 (rv);
1696
1697   guestfs_h *g = Guestfs_val (gv);
1698   if (g == NULL)
1699     caml_failwith ("vgcreate: used handle after closing it");
1700
1701   const char *volgroup = String_val (volgroupv);
1702   char **physvols = ocaml_guestfs_strings_val (physvolsv);
1703   int r;
1704
1705   caml_enter_blocking_section ();
1706   r = guestfs_vgcreate (g, volgroup, physvols);
1707   caml_leave_blocking_section ();
1708   ocaml_guestfs_free_strings (physvols);
1709   if (r == -1)
1710     ocaml_guestfs_raise_error (g, "vgcreate");
1711
1712   rv = Val_unit;
1713   CAMLreturn (rv);
1714 }
1715
1716 CAMLprim value
1717 ocaml_guestfs_lvcreate (value gv, value logvolv, value volgroupv, value mbytesv)
1718 {
1719   CAMLparam4 (gv, logvolv, volgroupv, mbytesv);
1720   CAMLlocal1 (rv);
1721
1722   guestfs_h *g = Guestfs_val (gv);
1723   if (g == NULL)
1724     caml_failwith ("lvcreate: used handle after closing it");
1725
1726   const char *logvol = String_val (logvolv);
1727   const char *volgroup = String_val (volgroupv);
1728   int mbytes = Int_val (mbytesv);
1729   int r;
1730
1731   caml_enter_blocking_section ();
1732   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1733   caml_leave_blocking_section ();
1734   if (r == -1)
1735     ocaml_guestfs_raise_error (g, "lvcreate");
1736
1737   rv = Val_unit;
1738   CAMLreturn (rv);
1739 }
1740
1741 CAMLprim value
1742 ocaml_guestfs_mkfs (value gv, value fstypev, value devicev)
1743 {
1744   CAMLparam3 (gv, fstypev, devicev);
1745   CAMLlocal1 (rv);
1746
1747   guestfs_h *g = Guestfs_val (gv);
1748   if (g == NULL)
1749     caml_failwith ("mkfs: used handle after closing it");
1750
1751   const char *fstype = String_val (fstypev);
1752   const char *device = String_val (devicev);
1753   int r;
1754
1755   caml_enter_blocking_section ();
1756   r = guestfs_mkfs (g, fstype, device);
1757   caml_leave_blocking_section ();
1758   if (r == -1)
1759     ocaml_guestfs_raise_error (g, "mkfs");
1760
1761   rv = Val_unit;
1762   CAMLreturn (rv);
1763 }
1764
1765 CAMLprim value
1766 ocaml_guestfs_sfdisk (value gv, value devicev, value cylsv, value headsv, value sectorsv, value linesv)
1767 {
1768   CAMLparam5 (gv, devicev, cylsv, headsv, sectorsv);
1769   CAMLxparam1 (linesv);
1770   CAMLlocal1 (rv);
1771
1772   guestfs_h *g = Guestfs_val (gv);
1773   if (g == NULL)
1774     caml_failwith ("sfdisk: used handle after closing it");
1775
1776   const char *device = String_val (devicev);
1777   int cyls = Int_val (cylsv);
1778   int heads = Int_val (headsv);
1779   int sectors = Int_val (sectorsv);
1780   char **lines = ocaml_guestfs_strings_val (linesv);
1781   int r;
1782
1783   caml_enter_blocking_section ();
1784   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1785   caml_leave_blocking_section ();
1786   ocaml_guestfs_free_strings (lines);
1787   if (r == -1)
1788     ocaml_guestfs_raise_error (g, "sfdisk");
1789
1790   rv = Val_unit;
1791   CAMLreturn (rv);
1792 }
1793
1794 CAMLprim value
1795 ocaml_guestfs_sfdisk_byte (value *argv, int argn)
1796 {
1797   return ocaml_guestfs_sfdisk (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4]);
1798 }
1799
1800 CAMLprim value
1801 ocaml_guestfs_write_file (value gv, value pathv, value contentv, value sizev)
1802 {
1803   CAMLparam4 (gv, pathv, contentv, sizev);
1804   CAMLlocal1 (rv);
1805
1806   guestfs_h *g = Guestfs_val (gv);
1807   if (g == NULL)
1808     caml_failwith ("write_file: used handle after closing it");
1809
1810   const char *path = String_val (pathv);
1811   const char *content = String_val (contentv);
1812   int size = Int_val (sizev);
1813   int r;
1814
1815   caml_enter_blocking_section ();
1816   r = guestfs_write_file (g, path, content, size);
1817   caml_leave_blocking_section ();
1818   if (r == -1)
1819     ocaml_guestfs_raise_error (g, "write_file");
1820
1821   rv = Val_unit;
1822   CAMLreturn (rv);
1823 }
1824
1825 CAMLprim value
1826 ocaml_guestfs_umount (value gv, value pathordevicev)
1827 {
1828   CAMLparam2 (gv, pathordevicev);
1829   CAMLlocal1 (rv);
1830
1831   guestfs_h *g = Guestfs_val (gv);
1832   if (g == NULL)
1833     caml_failwith ("umount: used handle after closing it");
1834
1835   const char *pathordevice = String_val (pathordevicev);
1836   int r;
1837
1838   caml_enter_blocking_section ();
1839   r = guestfs_umount (g, pathordevice);
1840   caml_leave_blocking_section ();
1841   if (r == -1)
1842     ocaml_guestfs_raise_error (g, "umount");
1843
1844   rv = Val_unit;
1845   CAMLreturn (rv);
1846 }
1847
1848 CAMLprim value
1849 ocaml_guestfs_mounts (value gv)
1850 {
1851   CAMLparam1 (gv);
1852   CAMLlocal1 (rv);
1853
1854   guestfs_h *g = Guestfs_val (gv);
1855   if (g == NULL)
1856     caml_failwith ("mounts: used handle after closing it");
1857
1858   int i;
1859   char **r;
1860
1861   caml_enter_blocking_section ();
1862   r = guestfs_mounts (g);
1863   caml_leave_blocking_section ();
1864   if (r == NULL)
1865     ocaml_guestfs_raise_error (g, "mounts");
1866
1867   rv = caml_copy_string_array ((const char **) r);
1868   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1869   free (r);
1870   CAMLreturn (rv);
1871 }
1872
1873 CAMLprim value
1874 ocaml_guestfs_umount_all (value gv)
1875 {
1876   CAMLparam1 (gv);
1877   CAMLlocal1 (rv);
1878
1879   guestfs_h *g = Guestfs_val (gv);
1880   if (g == NULL)
1881     caml_failwith ("umount_all: used handle after closing it");
1882
1883   int r;
1884
1885   caml_enter_blocking_section ();
1886   r = guestfs_umount_all (g);
1887   caml_leave_blocking_section ();
1888   if (r == -1)
1889     ocaml_guestfs_raise_error (g, "umount_all");
1890
1891   rv = Val_unit;
1892   CAMLreturn (rv);
1893 }
1894
1895 CAMLprim value
1896 ocaml_guestfs_lvm_remove_all (value gv)
1897 {
1898   CAMLparam1 (gv);
1899   CAMLlocal1 (rv);
1900
1901   guestfs_h *g = Guestfs_val (gv);
1902   if (g == NULL)
1903     caml_failwith ("lvm_remove_all: used handle after closing it");
1904
1905   int r;
1906
1907   caml_enter_blocking_section ();
1908   r = guestfs_lvm_remove_all (g);
1909   caml_leave_blocking_section ();
1910   if (r == -1)
1911     ocaml_guestfs_raise_error (g, "lvm_remove_all");
1912
1913   rv = Val_unit;
1914   CAMLreturn (rv);
1915 }
1916
1917 CAMLprim value
1918 ocaml_guestfs_file (value gv, value pathv)
1919 {
1920   CAMLparam2 (gv, pathv);
1921   CAMLlocal1 (rv);
1922
1923   guestfs_h *g = Guestfs_val (gv);
1924   if (g == NULL)
1925     caml_failwith ("file: used handle after closing it");
1926
1927   const char *path = String_val (pathv);
1928   char *r;
1929
1930   caml_enter_blocking_section ();
1931   r = guestfs_file (g, path);
1932   caml_leave_blocking_section ();
1933   if (r == NULL)
1934     ocaml_guestfs_raise_error (g, "file");
1935
1936   rv = caml_copy_string (r);
1937   free (r);
1938   CAMLreturn (rv);
1939 }
1940
1941 CAMLprim value
1942 ocaml_guestfs_command (value gv, value argumentsv)
1943 {
1944   CAMLparam2 (gv, argumentsv);
1945   CAMLlocal1 (rv);
1946
1947   guestfs_h *g = Guestfs_val (gv);
1948   if (g == NULL)
1949     caml_failwith ("command: used handle after closing it");
1950
1951   char **arguments = ocaml_guestfs_strings_val (argumentsv);
1952   char *r;
1953
1954   caml_enter_blocking_section ();
1955   r = guestfs_command (g, arguments);
1956   caml_leave_blocking_section ();
1957   ocaml_guestfs_free_strings (arguments);
1958   if (r == NULL)
1959     ocaml_guestfs_raise_error (g, "command");
1960
1961   rv = caml_copy_string (r);
1962   free (r);
1963   CAMLreturn (rv);
1964 }
1965
1966 CAMLprim value
1967 ocaml_guestfs_command_lines (value gv, value argumentsv)
1968 {
1969   CAMLparam2 (gv, argumentsv);
1970   CAMLlocal1 (rv);
1971
1972   guestfs_h *g = Guestfs_val (gv);
1973   if (g == NULL)
1974     caml_failwith ("command_lines: used handle after closing it");
1975
1976   char **arguments = ocaml_guestfs_strings_val (argumentsv);
1977   int i;
1978   char **r;
1979
1980   caml_enter_blocking_section ();
1981   r = guestfs_command_lines (g, arguments);
1982   caml_leave_blocking_section ();
1983   ocaml_guestfs_free_strings (arguments);
1984   if (r == NULL)
1985     ocaml_guestfs_raise_error (g, "command_lines");
1986
1987   rv = caml_copy_string_array ((const char **) r);
1988   for (i = 0; r[i] != NULL; ++i) free (r[i]);
1989   free (r);
1990   CAMLreturn (rv);
1991 }
1992
1993 CAMLprim value
1994 ocaml_guestfs_stat (value gv, value pathv)
1995 {
1996   CAMLparam2 (gv, pathv);
1997   CAMLlocal1 (rv);
1998
1999   guestfs_h *g = Guestfs_val (gv);
2000   if (g == NULL)
2001     caml_failwith ("stat: used handle after closing it");
2002
2003   const char *path = String_val (pathv);
2004   struct guestfs_stat *r;
2005
2006   caml_enter_blocking_section ();
2007   r = guestfs_stat (g, path);
2008   caml_leave_blocking_section ();
2009   if (r == NULL)
2010     ocaml_guestfs_raise_error (g, "stat");
2011
2012   rv = copy_stat (r);
2013   free (r);
2014   CAMLreturn (rv);
2015 }
2016
2017 CAMLprim value
2018 ocaml_guestfs_lstat (value gv, value pathv)
2019 {
2020   CAMLparam2 (gv, pathv);
2021   CAMLlocal1 (rv);
2022
2023   guestfs_h *g = Guestfs_val (gv);
2024   if (g == NULL)
2025     caml_failwith ("lstat: used handle after closing it");
2026
2027   const char *path = String_val (pathv);
2028   struct guestfs_stat *r;
2029
2030   caml_enter_blocking_section ();
2031   r = guestfs_lstat (g, path);
2032   caml_leave_blocking_section ();
2033   if (r == NULL)
2034     ocaml_guestfs_raise_error (g, "lstat");
2035
2036   rv = copy_stat (r);
2037   free (r);
2038   CAMLreturn (rv);
2039 }
2040
2041 CAMLprim value
2042 ocaml_guestfs_statvfs (value gv, value pathv)
2043 {
2044   CAMLparam2 (gv, pathv);
2045   CAMLlocal1 (rv);
2046
2047   guestfs_h *g = Guestfs_val (gv);
2048   if (g == NULL)
2049     caml_failwith ("statvfs: used handle after closing it");
2050
2051   const char *path = String_val (pathv);
2052   struct guestfs_statvfs *r;
2053
2054   caml_enter_blocking_section ();
2055   r = guestfs_statvfs (g, path);
2056   caml_leave_blocking_section ();
2057   if (r == NULL)
2058     ocaml_guestfs_raise_error (g, "statvfs");
2059
2060   rv = copy_statvfs (r);
2061   free (r);
2062   CAMLreturn (rv);
2063 }
2064
2065 CAMLprim value
2066 ocaml_guestfs_tune2fs_l (value gv, value devicev)
2067 {
2068   CAMLparam2 (gv, devicev);
2069   CAMLlocal1 (rv);
2070
2071   guestfs_h *g = Guestfs_val (gv);
2072   if (g == NULL)
2073     caml_failwith ("tune2fs_l: used handle after closing it");
2074
2075   const char *device = String_val (devicev);
2076   int i;
2077   char **r;
2078
2079   caml_enter_blocking_section ();
2080   r = guestfs_tune2fs_l (g, device);
2081   caml_leave_blocking_section ();
2082   if (r == NULL)
2083     ocaml_guestfs_raise_error (g, "tune2fs_l");
2084
2085   rv = copy_table (r);
2086   for (i = 0; r[i] != NULL; ++i) free (r[i]);
2087   free (r);
2088   CAMLreturn (rv);
2089 }
2090
2091 CAMLprim value
2092 ocaml_guestfs_blockdev_setro (value gv, value devicev)
2093 {
2094   CAMLparam2 (gv, devicev);
2095   CAMLlocal1 (rv);
2096
2097   guestfs_h *g = Guestfs_val (gv);
2098   if (g == NULL)
2099     caml_failwith ("blockdev_setro: used handle after closing it");
2100
2101   const char *device = String_val (devicev);
2102   int r;
2103
2104   caml_enter_blocking_section ();
2105   r = guestfs_blockdev_setro (g, device);
2106   caml_leave_blocking_section ();
2107   if (r == -1)
2108     ocaml_guestfs_raise_error (g, "blockdev_setro");
2109
2110   rv = Val_unit;
2111   CAMLreturn (rv);
2112 }
2113
2114 CAMLprim value
2115 ocaml_guestfs_blockdev_setrw (value gv, value devicev)
2116 {
2117   CAMLparam2 (gv, devicev);
2118   CAMLlocal1 (rv);
2119
2120   guestfs_h *g = Guestfs_val (gv);
2121   if (g == NULL)
2122     caml_failwith ("blockdev_setrw: used handle after closing it");
2123
2124   const char *device = String_val (devicev);
2125   int r;
2126
2127   caml_enter_blocking_section ();
2128   r = guestfs_blockdev_setrw (g, device);
2129   caml_leave_blocking_section ();
2130   if (r == -1)
2131     ocaml_guestfs_raise_error (g, "blockdev_setrw");
2132
2133   rv = Val_unit;
2134   CAMLreturn (rv);
2135 }
2136
2137 CAMLprim value
2138 ocaml_guestfs_blockdev_getro (value gv, value devicev)
2139 {
2140   CAMLparam2 (gv, devicev);
2141   CAMLlocal1 (rv);
2142
2143   guestfs_h *g = Guestfs_val (gv);
2144   if (g == NULL)
2145     caml_failwith ("blockdev_getro: used handle after closing it");
2146
2147   const char *device = String_val (devicev);
2148   int r;
2149
2150   caml_enter_blocking_section ();
2151   r = guestfs_blockdev_getro (g, device);
2152   caml_leave_blocking_section ();
2153   if (r == -1)
2154     ocaml_guestfs_raise_error (g, "blockdev_getro");
2155
2156   rv = Val_bool (r);
2157   CAMLreturn (rv);
2158 }
2159
2160 CAMLprim value
2161 ocaml_guestfs_blockdev_getss (value gv, value devicev)
2162 {
2163   CAMLparam2 (gv, devicev);
2164   CAMLlocal1 (rv);
2165
2166   guestfs_h *g = Guestfs_val (gv);
2167   if (g == NULL)
2168     caml_failwith ("blockdev_getss: used handle after closing it");
2169
2170   const char *device = String_val (devicev);
2171   int r;
2172
2173   caml_enter_blocking_section ();
2174   r = guestfs_blockdev_getss (g, device);
2175   caml_leave_blocking_section ();
2176   if (r == -1)
2177     ocaml_guestfs_raise_error (g, "blockdev_getss");
2178
2179   rv = Val_int (r);
2180   CAMLreturn (rv);
2181 }
2182
2183 CAMLprim value
2184 ocaml_guestfs_blockdev_getbsz (value gv, value devicev)
2185 {
2186   CAMLparam2 (gv, devicev);
2187   CAMLlocal1 (rv);
2188
2189   guestfs_h *g = Guestfs_val (gv);
2190   if (g == NULL)
2191     caml_failwith ("blockdev_getbsz: used handle after closing it");
2192
2193   const char *device = String_val (devicev);
2194   int r;
2195
2196   caml_enter_blocking_section ();
2197   r = guestfs_blockdev_getbsz (g, device);
2198   caml_leave_blocking_section ();
2199   if (r == -1)
2200     ocaml_guestfs_raise_error (g, "blockdev_getbsz");
2201
2202   rv = Val_int (r);
2203   CAMLreturn (rv);
2204 }
2205
2206 CAMLprim value
2207 ocaml_guestfs_blockdev_setbsz (value gv, value devicev, value blocksizev)
2208 {
2209   CAMLparam3 (gv, devicev, blocksizev);
2210   CAMLlocal1 (rv);
2211
2212   guestfs_h *g = Guestfs_val (gv);
2213   if (g == NULL)
2214     caml_failwith ("blockdev_setbsz: used handle after closing it");
2215
2216   const char *device = String_val (devicev);
2217   int blocksize = Int_val (blocksizev);
2218   int r;
2219
2220   caml_enter_blocking_section ();
2221   r = guestfs_blockdev_setbsz (g, device, blocksize);
2222   caml_leave_blocking_section ();
2223   if (r == -1)
2224     ocaml_guestfs_raise_error (g, "blockdev_setbsz");
2225
2226   rv = Val_unit;
2227   CAMLreturn (rv);
2228 }
2229
2230 CAMLprim value
2231 ocaml_guestfs_blockdev_getsz (value gv, value devicev)
2232 {
2233   CAMLparam2 (gv, devicev);
2234   CAMLlocal1 (rv);
2235
2236   guestfs_h *g = Guestfs_val (gv);
2237   if (g == NULL)
2238     caml_failwith ("blockdev_getsz: used handle after closing it");
2239
2240   const char *device = String_val (devicev);
2241   int64_t r;
2242
2243   caml_enter_blocking_section ();
2244   r = guestfs_blockdev_getsz (g, device);
2245   caml_leave_blocking_section ();
2246   if (r == -1)
2247     ocaml_guestfs_raise_error (g, "blockdev_getsz");
2248
2249   rv = caml_copy_int64 (r);
2250   CAMLreturn (rv);
2251 }
2252
2253 CAMLprim value
2254 ocaml_guestfs_blockdev_getsize64 (value gv, value devicev)
2255 {
2256   CAMLparam2 (gv, devicev);
2257   CAMLlocal1 (rv);
2258
2259   guestfs_h *g = Guestfs_val (gv);
2260   if (g == NULL)
2261     caml_failwith ("blockdev_getsize64: used handle after closing it");
2262
2263   const char *device = String_val (devicev);
2264   int64_t r;
2265
2266   caml_enter_blocking_section ();
2267   r = guestfs_blockdev_getsize64 (g, device);
2268   caml_leave_blocking_section ();
2269   if (r == -1)
2270     ocaml_guestfs_raise_error (g, "blockdev_getsize64");
2271
2272   rv = caml_copy_int64 (r);
2273   CAMLreturn (rv);
2274 }
2275
2276 CAMLprim value
2277 ocaml_guestfs_blockdev_flushbufs (value gv, value devicev)
2278 {
2279   CAMLparam2 (gv, devicev);
2280   CAMLlocal1 (rv);
2281
2282   guestfs_h *g = Guestfs_val (gv);
2283   if (g == NULL)
2284     caml_failwith ("blockdev_flushbufs: used handle after closing it");
2285
2286   const char *device = String_val (devicev);
2287   int r;
2288
2289   caml_enter_blocking_section ();
2290   r = guestfs_blockdev_flushbufs (g, device);
2291   caml_leave_blocking_section ();
2292   if (r == -1)
2293     ocaml_guestfs_raise_error (g, "blockdev_flushbufs");
2294
2295   rv = Val_unit;
2296   CAMLreturn (rv);
2297 }
2298
2299 CAMLprim value
2300 ocaml_guestfs_blockdev_rereadpt (value gv, value devicev)
2301 {
2302   CAMLparam2 (gv, devicev);
2303   CAMLlocal1 (rv);
2304
2305   guestfs_h *g = Guestfs_val (gv);
2306   if (g == NULL)
2307     caml_failwith ("blockdev_rereadpt: used handle after closing it");
2308
2309   const char *device = String_val (devicev);
2310   int r;
2311
2312   caml_enter_blocking_section ();
2313   r = guestfs_blockdev_rereadpt (g, device);
2314   caml_leave_blocking_section ();
2315   if (r == -1)
2316     ocaml_guestfs_raise_error (g, "blockdev_rereadpt");
2317
2318   rv = Val_unit;
2319   CAMLreturn (rv);
2320 }
2321
2322 CAMLprim value
2323 ocaml_guestfs_upload (value gv, value filenamev, value remotefilenamev)
2324 {
2325   CAMLparam3 (gv, filenamev, remotefilenamev);
2326   CAMLlocal1 (rv);
2327
2328   guestfs_h *g = Guestfs_val (gv);
2329   if (g == NULL)
2330     caml_failwith ("upload: used handle after closing it");
2331
2332   const char *filename = String_val (filenamev);
2333   const char *remotefilename = String_val (remotefilenamev);
2334   int r;
2335
2336   caml_enter_blocking_section ();
2337   r = guestfs_upload (g, filename, remotefilename);
2338   caml_leave_blocking_section ();
2339   if (r == -1)
2340     ocaml_guestfs_raise_error (g, "upload");
2341
2342   rv = Val_unit;
2343   CAMLreturn (rv);
2344 }
2345
2346 CAMLprim value
2347 ocaml_guestfs_download (value gv, value remotefilenamev, value filenamev)
2348 {
2349   CAMLparam3 (gv, remotefilenamev, filenamev);
2350   CAMLlocal1 (rv);
2351
2352   guestfs_h *g = Guestfs_val (gv);
2353   if (g == NULL)
2354     caml_failwith ("download: used handle after closing it");
2355
2356   const char *remotefilename = String_val (remotefilenamev);
2357   const char *filename = String_val (filenamev);
2358   int r;
2359
2360   caml_enter_blocking_section ();
2361   r = guestfs_download (g, remotefilename, filename);
2362   caml_leave_blocking_section ();
2363   if (r == -1)
2364     ocaml_guestfs_raise_error (g, "download");
2365
2366   rv = Val_unit;
2367   CAMLreturn (rv);
2368 }
2369
2370 CAMLprim value
2371 ocaml_guestfs_checksum (value gv, value csumtypev, value pathv)
2372 {
2373   CAMLparam3 (gv, csumtypev, pathv);
2374   CAMLlocal1 (rv);
2375
2376   guestfs_h *g = Guestfs_val (gv);
2377   if (g == NULL)
2378     caml_failwith ("checksum: used handle after closing it");
2379
2380   const char *csumtype = String_val (csumtypev);
2381   const char *path = String_val (pathv);
2382   char *r;
2383
2384   caml_enter_blocking_section ();
2385   r = guestfs_checksum (g, csumtype, path);
2386   caml_leave_blocking_section ();
2387   if (r == NULL)
2388     ocaml_guestfs_raise_error (g, "checksum");
2389
2390   rv = caml_copy_string (r);
2391   free (r);
2392   CAMLreturn (rv);
2393 }
2394
2395 CAMLprim value
2396 ocaml_guestfs_tar_in (value gv, value tarfilev, value directoryv)
2397 {
2398   CAMLparam3 (gv, tarfilev, directoryv);
2399   CAMLlocal1 (rv);
2400
2401   guestfs_h *g = Guestfs_val (gv);
2402   if (g == NULL)
2403     caml_failwith ("tar_in: used handle after closing it");
2404
2405   const char *tarfile = String_val (tarfilev);
2406   const char *directory = String_val (directoryv);
2407   int r;
2408
2409   caml_enter_blocking_section ();
2410   r = guestfs_tar_in (g, tarfile, directory);
2411   caml_leave_blocking_section ();
2412   if (r == -1)
2413     ocaml_guestfs_raise_error (g, "tar_in");
2414
2415   rv = Val_unit;
2416   CAMLreturn (rv);
2417 }
2418
2419 CAMLprim value
2420 ocaml_guestfs_tar_out (value gv, value directoryv, value tarfilev)
2421 {
2422   CAMLparam3 (gv, directoryv, tarfilev);
2423   CAMLlocal1 (rv);
2424
2425   guestfs_h *g = Guestfs_val (gv);
2426   if (g == NULL)
2427     caml_failwith ("tar_out: used handle after closing it");
2428
2429   const char *directory = String_val (directoryv);
2430   const char *tarfile = String_val (tarfilev);
2431   int r;
2432
2433   caml_enter_blocking_section ();
2434   r = guestfs_tar_out (g, directory, tarfile);
2435   caml_leave_blocking_section ();
2436   if (r == -1)
2437     ocaml_guestfs_raise_error (g, "tar_out");
2438
2439   rv = Val_unit;
2440   CAMLreturn (rv);
2441 }
2442
2443 CAMLprim value
2444 ocaml_guestfs_tgz_in (value gv, value tarballv, value directoryv)
2445 {
2446   CAMLparam3 (gv, tarballv, directoryv);
2447   CAMLlocal1 (rv);
2448
2449   guestfs_h *g = Guestfs_val (gv);
2450   if (g == NULL)
2451     caml_failwith ("tgz_in: used handle after closing it");
2452
2453   const char *tarball = String_val (tarballv);
2454   const char *directory = String_val (directoryv);
2455   int r;
2456
2457   caml_enter_blocking_section ();
2458   r = guestfs_tgz_in (g, tarball, directory);
2459   caml_leave_blocking_section ();
2460   if (r == -1)
2461     ocaml_guestfs_raise_error (g, "tgz_in");
2462
2463   rv = Val_unit;
2464   CAMLreturn (rv);
2465 }
2466
2467 CAMLprim value
2468 ocaml_guestfs_tgz_out (value gv, value directoryv, value tarballv)
2469 {
2470   CAMLparam3 (gv, directoryv, tarballv);
2471   CAMLlocal1 (rv);
2472
2473   guestfs_h *g = Guestfs_val (gv);
2474   if (g == NULL)
2475     caml_failwith ("tgz_out: used handle after closing it");
2476
2477   const char *directory = String_val (directoryv);
2478   const char *tarball = String_val (tarballv);
2479   int r;
2480
2481   caml_enter_blocking_section ();
2482   r = guestfs_tgz_out (g, directory, tarball);
2483   caml_leave_blocking_section ();
2484   if (r == -1)
2485     ocaml_guestfs_raise_error (g, "tgz_out");
2486
2487   rv = Val_unit;
2488   CAMLreturn (rv);
2489 }
2490