X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=ocaml%2Fguestfs_c_actions.c;h=c0618b2936ee4ee047e0e4275119a86d0ba02ae6;hp=6675cf8cc1d45a798c5a0e7b73e14a65b52a12cf;hb=b348eacbc4d84337856cf7cca518d61c63e92631;hpb=286841877f4223d67ec00b83e5a2aabfbb9e19ed diff --git a/ocaml/guestfs_c_actions.c b/ocaml/guestfs_c_actions.c index 6675cf8..c0618b2 100644 --- a/ocaml/guestfs_c_actions.c +++ b/ocaml/guestfs_c_actions.c @@ -35,6 +35,33 @@ #include "guestfs_c.h" +/* Copy a hashtable of string pairs into an assoc-list. We return + * the list in reverse order, but hashtables aren't supposed to be + * ordered anyway. + */ +static CAMLprim value +copy_table (char * const * argv) +{ + CAMLparam0 (); + CAMLlocal5 (rv, pairv, kv, vv, cons); + int i; + + rv = Val_int (0); + for (i = 0; argv[i] != NULL; i += 2) { + kv = caml_copy_string (argv[i]); + vv = caml_copy_string (argv[i+1]); + pairv = caml_alloc (2, 0); + Store_field (pairv, 0, kv); + Store_field (pairv, 1, vv); + cons = caml_alloc (2, 0); + Store_field (cons, 1, rv); + rv = cons; + Store_field (cons, 0, pairv); + } + + CAMLreturn (rv); +} + static CAMLprim value copy_lvm_pv (const struct guestfs_lvm_pv *pv) { @@ -233,6 +260,74 @@ copy_lvm_lv_list (const struct guestfs_lvm_lv_list *lvs) } } +static CAMLprim value +copy_stat (const struct guestfs_stat *stat) +{ + CAMLparam0 (); + CAMLlocal2 (rv, v); + + rv = caml_alloc (13, 0); + v = caml_copy_int64 (stat->dev); + Store_field (rv, 0, v); + v = caml_copy_int64 (stat->ino); + Store_field (rv, 1, v); + v = caml_copy_int64 (stat->mode); + Store_field (rv, 2, v); + v = caml_copy_int64 (stat->nlink); + Store_field (rv, 3, v); + v = caml_copy_int64 (stat->uid); + Store_field (rv, 4, v); + v = caml_copy_int64 (stat->gid); + Store_field (rv, 5, v); + v = caml_copy_int64 (stat->rdev); + Store_field (rv, 6, v); + v = caml_copy_int64 (stat->size); + Store_field (rv, 7, v); + v = caml_copy_int64 (stat->blksize); + Store_field (rv, 8, v); + v = caml_copy_int64 (stat->blocks); + Store_field (rv, 9, v); + v = caml_copy_int64 (stat->atime); + Store_field (rv, 10, v); + v = caml_copy_int64 (stat->mtime); + Store_field (rv, 11, v); + v = caml_copy_int64 (stat->ctime); + Store_field (rv, 12, v); + CAMLreturn (rv); +} + +static CAMLprim value +copy_statvfs (const struct guestfs_statvfs *statvfs) +{ + CAMLparam0 (); + CAMLlocal2 (rv, v); + + rv = caml_alloc (11, 0); + v = caml_copy_int64 (statvfs->bsize); + Store_field (rv, 0, v); + v = caml_copy_int64 (statvfs->frsize); + Store_field (rv, 1, v); + v = caml_copy_int64 (statvfs->blocks); + Store_field (rv, 2, v); + v = caml_copy_int64 (statvfs->bfree); + Store_field (rv, 3, v); + v = caml_copy_int64 (statvfs->bavail); + Store_field (rv, 4, v); + v = caml_copy_int64 (statvfs->files); + Store_field (rv, 5, v); + v = caml_copy_int64 (statvfs->ffree); + Store_field (rv, 6, v); + v = caml_copy_int64 (statvfs->favail); + Store_field (rv, 7, v); + v = caml_copy_int64 (statvfs->fsid); + Store_field (rv, 8, v); + v = caml_copy_int64 (statvfs->flag); + Store_field (rv, 9, v); + v = caml_copy_int64 (statvfs->namemax); + Store_field (rv, 10, v); + CAMLreturn (rv); +} + CAMLprim value ocaml_guestfs_launch (value gv) { @@ -1347,3 +1442,726 @@ ocaml_guestfs_chown (value gv, value ownerv, value groupv, value pathv) CAMLreturn (rv); } +CAMLprim value +ocaml_guestfs_exists (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("exists: used handle after closing it"); + + const char *path = String_val (pathv); + int r; + + caml_enter_blocking_section (); + r = guestfs_exists (g, path); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "exists"); + + rv = Val_bool (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_is_file (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("is_file: used handle after closing it"); + + const char *path = String_val (pathv); + int r; + + caml_enter_blocking_section (); + r = guestfs_is_file (g, path); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "is_file"); + + rv = Val_bool (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_is_dir (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("is_dir: used handle after closing it"); + + const char *path = String_val (pathv); + int r; + + caml_enter_blocking_section (); + r = guestfs_is_dir (g, path); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "is_dir"); + + rv = Val_bool (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_pvcreate (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("pvcreate: used handle after closing it"); + + const char *device = String_val (devicev); + int r; + + caml_enter_blocking_section (); + r = guestfs_pvcreate (g, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "pvcreate"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_vgcreate (value gv, value volgroupv, value physvolsv) +{ + CAMLparam3 (gv, volgroupv, physvolsv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("vgcreate: used handle after closing it"); + + const char *volgroup = String_val (volgroupv); + char **physvols = ocaml_guestfs_strings_val (physvolsv); + int r; + + caml_enter_blocking_section (); + r = guestfs_vgcreate (g, volgroup, physvols); + caml_leave_blocking_section (); + ocaml_guestfs_free_strings (physvols); + if (r == -1) + ocaml_guestfs_raise_error (g, "vgcreate"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_lvcreate (value gv, value logvolv, value volgroupv, value mbytesv) +{ + CAMLparam4 (gv, logvolv, volgroupv, mbytesv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("lvcreate: used handle after closing it"); + + const char *logvol = String_val (logvolv); + const char *volgroup = String_val (volgroupv); + int mbytes = Int_val (mbytesv); + int r; + + caml_enter_blocking_section (); + r = guestfs_lvcreate (g, logvol, volgroup, mbytes); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "lvcreate"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_mkfs (value gv, value fstypev, value devicev) +{ + CAMLparam3 (gv, fstypev, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("mkfs: used handle after closing it"); + + const char *fstype = String_val (fstypev); + const char *device = String_val (devicev); + int r; + + caml_enter_blocking_section (); + r = guestfs_mkfs (g, fstype, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "mkfs"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_sfdisk (value gv, value devicev, value cylsv, value headsv, value sectorsv, value linesv) +{ + CAMLparam5 (gv, devicev, cylsv, headsv, sectorsv); + CAMLxparam1 (linesv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("sfdisk: used handle after closing it"); + + const char *device = String_val (devicev); + int cyls = Int_val (cylsv); + int heads = Int_val (headsv); + int sectors = Int_val (sectorsv); + char **lines = ocaml_guestfs_strings_val (linesv); + int r; + + caml_enter_blocking_section (); + r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines); + caml_leave_blocking_section (); + ocaml_guestfs_free_strings (lines); + if (r == -1) + ocaml_guestfs_raise_error (g, "sfdisk"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_sfdisk_byte (value *argv, int argn) +{ + return ocaml_guestfs_sfdisk (argv[0], argv[0], argv[1], argv[2], argv[3], argv[4]); +} + +CAMLprim value +ocaml_guestfs_write_file (value gv, value pathv, value contentv, value sizev) +{ + CAMLparam4 (gv, pathv, contentv, sizev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("write_file: used handle after closing it"); + + const char *path = String_val (pathv); + const char *content = String_val (contentv); + int size = Int_val (sizev); + int r; + + caml_enter_blocking_section (); + r = guestfs_write_file (g, path, content, size); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "write_file"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_umount (value gv, value pathordevicev) +{ + CAMLparam2 (gv, pathordevicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("umount: used handle after closing it"); + + const char *pathordevice = String_val (pathordevicev); + int r; + + caml_enter_blocking_section (); + r = guestfs_umount (g, pathordevice); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "umount"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_mounts (value gv) +{ + CAMLparam1 (gv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("mounts: used handle after closing it"); + + int i; + char **r; + + caml_enter_blocking_section (); + r = guestfs_mounts (g); + caml_leave_blocking_section (); + if (r == NULL) + ocaml_guestfs_raise_error (g, "mounts"); + + rv = caml_copy_string_array ((const char **) r); + for (i = 0; r[i] != NULL; ++i) free (r[i]); + free (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_umount_all (value gv) +{ + CAMLparam1 (gv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("umount_all: used handle after closing it"); + + int r; + + caml_enter_blocking_section (); + r = guestfs_umount_all (g); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "umount_all"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_lvm_remove_all (value gv) +{ + CAMLparam1 (gv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("lvm_remove_all: used handle after closing it"); + + int r; + + caml_enter_blocking_section (); + r = guestfs_lvm_remove_all (g); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "lvm_remove_all"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_file (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("file: used handle after closing it"); + + const char *path = String_val (pathv); + char *r; + + caml_enter_blocking_section (); + r = guestfs_file (g, path); + caml_leave_blocking_section (); + if (r == NULL) + ocaml_guestfs_raise_error (g, "file"); + + rv = caml_copy_string (r); + free (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_command (value gv, value argumentsv) +{ + CAMLparam2 (gv, argumentsv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("command: used handle after closing it"); + + char **arguments = ocaml_guestfs_strings_val (argumentsv); + char *r; + + caml_enter_blocking_section (); + r = guestfs_command (g, arguments); + caml_leave_blocking_section (); + ocaml_guestfs_free_strings (arguments); + if (r == NULL) + ocaml_guestfs_raise_error (g, "command"); + + rv = caml_copy_string (r); + free (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_command_lines (value gv, value argumentsv) +{ + CAMLparam2 (gv, argumentsv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("command_lines: used handle after closing it"); + + char **arguments = ocaml_guestfs_strings_val (argumentsv); + int i; + char **r; + + caml_enter_blocking_section (); + r = guestfs_command_lines (g, arguments); + caml_leave_blocking_section (); + ocaml_guestfs_free_strings (arguments); + if (r == NULL) + ocaml_guestfs_raise_error (g, "command_lines"); + + rv = caml_copy_string_array ((const char **) r); + for (i = 0; r[i] != NULL; ++i) free (r[i]); + free (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_stat (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("stat: used handle after closing it"); + + const char *path = String_val (pathv); + struct guestfs_stat *r; + + caml_enter_blocking_section (); + r = guestfs_stat (g, path); + caml_leave_blocking_section (); + if (r == NULL) + ocaml_guestfs_raise_error (g, "stat"); + + rv = copy_stat (r); + free (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_lstat (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("lstat: used handle after closing it"); + + const char *path = String_val (pathv); + struct guestfs_stat *r; + + caml_enter_blocking_section (); + r = guestfs_lstat (g, path); + caml_leave_blocking_section (); + if (r == NULL) + ocaml_guestfs_raise_error (g, "lstat"); + + rv = copy_stat (r); + free (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_statvfs (value gv, value pathv) +{ + CAMLparam2 (gv, pathv); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("statvfs: used handle after closing it"); + + const char *path = String_val (pathv); + struct guestfs_statvfs *r; + + caml_enter_blocking_section (); + r = guestfs_statvfs (g, path); + caml_leave_blocking_section (); + if (r == NULL) + ocaml_guestfs_raise_error (g, "statvfs"); + + rv = copy_statvfs (r); + free (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_tune2fs_l (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("tune2fs_l: used handle after closing it"); + + const char *device = String_val (devicev); + int i; + char **r; + + caml_enter_blocking_section (); + r = guestfs_tune2fs_l (g, device); + caml_leave_blocking_section (); + if (r == NULL) + ocaml_guestfs_raise_error (g, "tune2fs_l"); + + rv = copy_table (r); + for (i = 0; r[i] != NULL; ++i) free (r[i]); + free (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_blockdev_setro (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("blockdev_setro: used handle after closing it"); + + const char *device = String_val (devicev); + int r; + + caml_enter_blocking_section (); + r = guestfs_blockdev_setro (g, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "blockdev_setro"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_blockdev_setrw (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("blockdev_setrw: used handle after closing it"); + + const char *device = String_val (devicev); + int r; + + caml_enter_blocking_section (); + r = guestfs_blockdev_setrw (g, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "blockdev_setrw"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_blockdev_getro (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("blockdev_getro: used handle after closing it"); + + const char *device = String_val (devicev); + int r; + + caml_enter_blocking_section (); + r = guestfs_blockdev_getro (g, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "blockdev_getro"); + + rv = Val_bool (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_blockdev_getss (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("blockdev_getss: used handle after closing it"); + + const char *device = String_val (devicev); + int r; + + caml_enter_blocking_section (); + r = guestfs_blockdev_getss (g, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "blockdev_getss"); + + rv = Val_int (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_blockdev_getbsz (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("blockdev_getbsz: used handle after closing it"); + + const char *device = String_val (devicev); + int r; + + caml_enter_blocking_section (); + r = guestfs_blockdev_getbsz (g, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "blockdev_getbsz"); + + rv = Val_int (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_blockdev_setbsz (value gv, value devicev, value blocksizev) +{ + CAMLparam3 (gv, devicev, blocksizev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("blockdev_setbsz: used handle after closing it"); + + const char *device = String_val (devicev); + int blocksize = Int_val (blocksizev); + int r; + + caml_enter_blocking_section (); + r = guestfs_blockdev_setbsz (g, device, blocksize); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "blockdev_setbsz"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_blockdev_getsz (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("blockdev_getsz: used handle after closing it"); + + const char *device = String_val (devicev); + int64_t r; + + caml_enter_blocking_section (); + r = guestfs_blockdev_getsz (g, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "blockdev_getsz"); + + rv = caml_copy_int64 (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_blockdev_getsize64 (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("blockdev_getsize64: used handle after closing it"); + + const char *device = String_val (devicev); + int64_t r; + + caml_enter_blocking_section (); + r = guestfs_blockdev_getsize64 (g, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "blockdev_getsize64"); + + rv = caml_copy_int64 (r); + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_blockdev_flushbufs (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("blockdev_flushbufs: used handle after closing it"); + + const char *device = String_val (devicev); + int r; + + caml_enter_blocking_section (); + r = guestfs_blockdev_flushbufs (g, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "blockdev_flushbufs"); + + rv = Val_unit; + CAMLreturn (rv); +} + +CAMLprim value +ocaml_guestfs_blockdev_rereadpt (value gv, value devicev) +{ + CAMLparam2 (gv, devicev); + CAMLlocal1 (rv); + + guestfs_h *g = Guestfs_val (gv); + if (g == NULL) + caml_failwith ("blockdev_rereadpt: used handle after closing it"); + + const char *device = String_val (devicev); + int r; + + caml_enter_blocking_section (); + r = guestfs_blockdev_rereadpt (g, device); + caml_leave_blocking_section (); + if (r == -1) + ocaml_guestfs_raise_error (g, "blockdev_rereadpt"); + + rv = Val_unit; + CAMLreturn (rv); +} +