From ad5abc8d367c9c410051062cae066b1b141b4c76 Mon Sep 17 00:00:00 2001 From: Richard Jones Date: Wed, 15 Apr 2009 13:59:07 +0100 Subject: [PATCH] Generated code for tune2fs-l command and RHashtable return type. --- daemon/actions.h | 1 + daemon/stubs.c | 31 ++++++++++++++++ fish/cmds.c | 24 ++++++++++++ fish/completion.c | 1 + fish/fish.c | 9 +++++ fish/fish.h | 1 + guestfish-actions.pod | 12 ++++++ guestfs-actions.pod | 19 ++++++++++ ocaml/guestfs.ml | 1 + ocaml/guestfs.mli | 3 ++ ocaml/guestfs_c_actions.c | 51 +++++++++++++++++++++++++ perl/Guestfs.xs | 19 ++++++++++ perl/lib/Sys/Guestfs.pm | 10 +++++ python/guestfs-py.c | 47 +++++++++++++++++++++++ python/guestfs.py | 3 ++ src/guestfs-actions.c | 78 +++++++++++++++++++++++++++++++++++++++ src/guestfs-actions.h | 1 + src/guestfs_protocol.c | 21 +++++++++++ src/guestfs_protocol.h | 20 +++++++++- src/guestfs_protocol.x | 9 +++++ tests.c | 8 ++++ 21 files changed, 368 insertions(+), 1 deletion(-) diff --git a/daemon/actions.h b/daemon/actions.h index c0f41ce15..53f3b79eb 100644 --- a/daemon/actions.h +++ b/daemon/actions.h @@ -75,3 +75,4 @@ extern char **do_command_lines (char * const* const arguments); extern guestfs_int_stat *do_stat (const char *path); extern guestfs_int_stat *do_lstat (const char *path); extern guestfs_int_statvfs *do_statvfs (const char *path); +extern char **do_tune2fs_l (const char *device); diff --git a/daemon/stubs.c b/daemon/stubs.c index 9662de809..a6175cbd4 100644 --- a/daemon/stubs.c +++ b/daemon/stubs.c @@ -1304,6 +1304,34 @@ done: xdr_free ((xdrproc_t) xdr_guestfs_statvfs_args, (char *) &args); } +static void tune2fs_l_stub (XDR *xdr_in) +{ + char **r; + struct guestfs_tune2fs_l_args args; + const char *device; + + memset (&args, 0, sizeof args); + + if (!xdr_guestfs_tune2fs_l_args (xdr_in, &args)) { + reply_with_error ("%s: daemon failed to decode procedure arguments", "tune2fs_l"); + return; + } + device = args.device; + + r = do_tune2fs_l (device); + if (r == NULL) + /* do_tune2fs_l has already called reply_with_error */ + goto done; + + struct guestfs_tune2fs_l_ret ret; + ret.superblock.superblock_len = count_strings (r); + ret.superblock.superblock_val = r; + reply ((xdrproc_t) &xdr_guestfs_tune2fs_l_ret, (char *) &ret); + free_strings (r); +done: + xdr_free ((xdrproc_t) xdr_guestfs_tune2fs_l_args, (char *) &args); +} + void dispatch_incoming_message (XDR *xdr_in) { switch (proc_nr) { @@ -1469,6 +1497,9 @@ void dispatch_incoming_message (XDR *xdr_in) case GUESTFS_PROC_STATVFS: statvfs_stub (xdr_in); break; + case GUESTFS_PROC_TUNE2FS_L: + tune2fs_l_stub (xdr_in); + break; default: reply_with_error ("dispatch_incoming_message: unknown procedure number %d", proc_nr); } diff --git a/fish/cmds.c b/fish/cmds.c index 60aee8c16..c68924a35 100644 --- a/fish/cmds.c +++ b/fish/cmds.c @@ -90,6 +90,7 @@ void list_commands (void) printf ("%-20s %s\n", "statvfs", "get file system statistics"); printf ("%-20s %s\n", "sync", "sync disks, writes are flushed through to the disk image"); printf ("%-20s %s\n", "touch", "update file timestamps or create a new file"); + printf ("%-20s %s\n", "tune2fs-l", "get ext2/ext3 superblock details"); printf ("%-20s %s\n", "umount", "unmount a filesystem"); printf ("%-20s %s\n", "umount-all", "unmount all filesystems"); printf ("%-20s %s\n", "vgcreate", "create an LVM volume group"); @@ -295,6 +296,9 @@ void display_command (const char *cmd) else if (strcasecmp (cmd, "statvfs") == 0) pod2text ("statvfs - get file system statistics", " statvfs \n\nReturns file system statistics for any mounted file system.\nC should be a file or directory in the mounted file system\n(typically it is the mount point itself, but it doesn't need to be).\n\nThis is the same as the C system call."); + else + if (strcasecmp (cmd, "tune2fs_l") == 0 || strcasecmp (cmd, "tune2fs-l") == 0) + pod2text ("tune2fs-l - get ext2/ext3 superblock details", " tune2fs-l \n\nThis returns the contents of the ext2 or ext3 filesystem superblock\non C.\n\nIt is the same as running C. See L\nmanpage for more details. The list of fields returned isn't\nclearly defined, and depends on both the version of C\nthat libguestfs was built against, and the filesystem itself."); else display_builtin_command (cmd); } @@ -1435,6 +1439,23 @@ static int run_statvfs (const char *cmd, int argc, char *argv[]) return 0; } +static int run_tune2fs_l (const char *cmd, int argc, char *argv[]) +{ + char **r; + const char *device; + if (argc != 1) { + fprintf (stderr, "%s should have 1 parameter(s)\n", cmd); + fprintf (stderr, "type 'help %s' for help on %s\n", cmd, cmd); + return -1; + } + device = argv[0]; + r = guestfs_tune2fs_l (g, device); + if (r == NULL) return -1; + print_table (r); + free_strings (r); + return 0; +} + int run_action (const char *cmd, int argc, char *argv[]) { if (strcasecmp (cmd, "launch") == 0 || strcasecmp (cmd, "run") == 0) @@ -1631,6 +1652,9 @@ int run_action (const char *cmd, int argc, char *argv[]) else if (strcasecmp (cmd, "statvfs") == 0) return run_statvfs (cmd, argc, argv); + else + if (strcasecmp (cmd, "tune2fs_l") == 0 || strcasecmp (cmd, "tune2fs-l") == 0) + return run_tune2fs_l (cmd, argc, argv); else { fprintf (stderr, "%s: unknown command\n", cmd); diff --git a/fish/completion.c b/fish/completion.c index 7b4f818a8..cee2b399d 100644 --- a/fish/completion.c +++ b/fish/completion.c @@ -98,6 +98,7 @@ static const char *commands[] = { "statvfs", "sync", "touch", + "tune2fs-l", "umount", "umount-all", "unmount", diff --git a/fish/fish.c b/fish/fish.c index b825626bc..e506f7ef6 100644 --- a/fish/fish.c +++ b/fish/fish.c @@ -645,6 +645,15 @@ print_strings (char * const * const argv) printf ("%s\n", argv[argc]); } +void +print_table (char * const * const argv) +{ + int i; + + for (i = 0; argv[i] != NULL; i += 2) + printf ("%s: %s\n", argv[i], argv[i+1]); +} + int is_true (const char *str) { diff --git a/fish/fish.h b/fish/fish.h index 86e5e3575..6cd4d9769 100644 --- a/fish/fish.h +++ b/fish/fish.h @@ -31,6 +31,7 @@ extern void list_builtin_commands (void); extern void display_builtin_command (const char *cmd); extern void free_strings (char **argv); extern void print_strings (char * const * const argv); +extern void print_table (char * const * const argv); extern int launch (guestfs_h *); extern int is_true (const char *str); extern char **parse_string_list (const char *str); diff --git a/guestfish-actions.pod b/guestfish-actions.pod index e240f4994..28f9559cc 100644 --- a/guestfish-actions.pod +++ b/guestfish-actions.pod @@ -631,6 +631,18 @@ Touch acts like the L command. It can be used to update the timestamps on a file, or, if the file does not exist, to create a new zero-length file. +=head2 tune2fs-l + + tune2fs-l device + +This returns the contents of the ext2 or ext3 filesystem superblock +on C. + +It is the same as running C. See L +manpage for more details. The list of fields returned isn't +clearly defined, and depends on both the version of C +that libguestfs was built against, and the filesystem itself. + =head2 umount | unmount umount pathordevice diff --git a/guestfs-actions.pod b/guestfs-actions.pod index 03378e0a3..889363a5b 100644 --- a/guestfs-actions.pod +++ b/guestfs-actions.pod @@ -854,6 +854,25 @@ to create a new zero-length file. This function returns 0 on success or -1 on error. +=head2 guestfs_tune2fs_l + + char **guestfs_tune2fs_l (guestfs_h *handle, + const char *device); + +This returns the contents of the ext2 or ext3 filesystem superblock +on C. + +It is the same as running C. See L +manpage for more details. The list of fields returned isn't +clearly defined, and depends on both the version of C +that libguestfs was built against, and the filesystem itself. + +This function returns a NULL-terminated array of +strings, or NULL if there was an error. +The array of strings will always have length C<2n+1>, where +C keys and values alternate, followed by the trailing NULL entry. +I. + =head2 guestfs_umount int guestfs_umount (guestfs_h *handle, diff --git a/ocaml/guestfs.ml b/ocaml/guestfs.ml index f0344ac77..e29daea50 100644 --- a/ocaml/guestfs.ml +++ b/ocaml/guestfs.ml @@ -181,3 +181,4 @@ external command_lines : t -> string array -> string array = "ocaml_guestfs_comm external stat : t -> string -> stat = "ocaml_guestfs_stat" external lstat : t -> string -> stat = "ocaml_guestfs_lstat" external statvfs : t -> string -> statvfs = "ocaml_guestfs_statvfs" +external tune2fs_l : t -> string -> (string * string) list = "ocaml_guestfs_tune2fs_l" diff --git a/ocaml/guestfs.mli b/ocaml/guestfs.mli index 30629681b..e6f5231e1 100644 --- a/ocaml/guestfs.mli +++ b/ocaml/guestfs.mli @@ -322,3 +322,6 @@ val lstat : t -> string -> stat val statvfs : t -> string -> statvfs (** get file system statistics *) +val tune2fs_l : t -> string -> (string * string) list +(** get ext2/ext3 superblock details *) + diff --git a/ocaml/guestfs_c_actions.c b/ocaml/guestfs_c_actions.c index 01fbcb065..b1c4652bb 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) { @@ -1881,3 +1908,27 @@ ocaml_guestfs_statvfs (value gv, value pathv) 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); + 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); + free (r); + CAMLreturn (rv); +} + diff --git a/perl/Guestfs.xs b/perl/Guestfs.xs index 37a15e097..93abd9ec0 100644 --- a/perl/Guestfs.xs +++ b/perl/Guestfs.xs @@ -1087,3 +1087,22 @@ PREINIT: PUSHs (sv_2mortal (my_newSVll (statbuf->namemax))); free (statbuf); +void +tune2fs_l (g, device) + guestfs_h *g; + char *device; +PREINIT: + char **superblock; + int i, n; + PPCODE: + superblock = guestfs_tune2fs_l (g, device); + if (superblock == NULL) + croak ("tune2fs_l: %s", guestfs_last_error (g)); + for (n = 0; superblock[n] != NULL; ++n) /**/; + EXTEND (SP, n); + for (i = 0; i < n; ++i) { + PUSHs (sv_2mortal (newSVpv (superblock[i], 0))); + free (superblock[i]); + } + free (superblock); + diff --git a/perl/lib/Sys/Guestfs.pm b/perl/lib/Sys/Guestfs.pm index 09663bc5e..36bedd5e1 100644 --- a/perl/lib/Sys/Guestfs.pm +++ b/perl/lib/Sys/Guestfs.pm @@ -606,6 +606,16 @@ Touch acts like the L command. It can be used to update the timestamps on a file, or, if the file does not exist, to create a new zero-length file. +=item %superblock = $h->tune2fs_l ($device); + +This returns the contents of the ext2 or ext3 filesystem superblock +on C. + +It is the same as running C. See L +manpage for more details. The list of fields returned isn't +clearly defined, and depends on both the version of C +that libguestfs was built against, and the filesystem itself. + =item $h->umount ($pathordevice); This unmounts the given filesystem. The filesystem may be diff --git a/python/guestfs-py.c b/python/guestfs-py.c index 81c87982a..8fbab7471 100644 --- a/python/guestfs-py.c +++ b/python/guestfs-py.c @@ -92,6 +92,27 @@ put_string_list (char * const * const argv) return list; } +static PyObject * +put_table (char * const * const argv) +{ + PyObject *list, *item; + int argc, i; + + for (argc = 0; argv[argc] != NULL; ++argc) + ; + + list = PyList_New (argc >> 1); + for (i = 0; i < argc; i += 2) { + PyObject *item; + item = PyTuple_New (2); + PyTuple_SetItem (item, 0, PyString_FromString (argv[i])); + PyTuple_SetItem (item, 1, PyString_FromString (argv[i+1])); + PyList_SetItem (list, i >> 1, item); + } + + return list; +} + static void free_strings (char **argv) { @@ -2030,6 +2051,31 @@ py_guestfs_statvfs (PyObject *self, PyObject *args) return py_r; } +static PyObject * +py_guestfs_tune2fs_l (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + const char *device; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l", + &py_g, &device)) + return NULL; + g = get_handle (py_g); + + r = guestfs_tune2fs_l (g, device); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_table (r); + free (r); + return py_r; +} + static PyMethodDef methods[] = { { (char *) "create", py_guestfs_create, METH_VARARGS, NULL }, { (char *) "close", py_guestfs_close, METH_VARARGS, NULL }, @@ -2099,6 +2145,7 @@ static PyMethodDef methods[] = { { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL }, { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL }, { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL }, + { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL }, { NULL, NULL, 0, NULL } }; diff --git a/python/guestfs.py b/python/guestfs.py index 2e0be5c53..95156fc2d 100644 --- a/python/guestfs.py +++ b/python/guestfs.py @@ -225,3 +225,6 @@ class GuestFS: def statvfs (self, path): return libguestfsmod.statvfs (self._o, path) + def tune2fs_l (self, device): + return libguestfsmod.tune2fs_l (self._o, device) + diff --git a/src/guestfs-actions.c b/src/guestfs-actions.c index 8f40102e5..0961df69c 100644 --- a/src/guestfs-actions.c +++ b/src/guestfs-actions.c @@ -3924,3 +3924,81 @@ struct guestfs_statvfs *guestfs_statvfs (guestfs_h *g, return safe_memdup (g, &rv.ret.statbuf, sizeof (rv.ret.statbuf)); } +struct tune2fs_l_rv { + int cb_done; /* flag to indicate callback was called */ + struct guestfs_message_header hdr; + struct guestfs_message_error err; + struct guestfs_tune2fs_l_ret ret; +}; + +static void tune2fs_l_cb (guestfs_h *g, void *data, XDR *xdr) +{ + struct tune2fs_l_rv *rv = (struct tune2fs_l_rv *) data; + + if (!xdr_guestfs_message_header (xdr, &rv->hdr)) { + error (g, "guestfs_tune2fs_l: failed to parse reply header"); + return; + } + if (rv->hdr.status == GUESTFS_STATUS_ERROR) { + if (!xdr_guestfs_message_error (xdr, &rv->err)) { + error (g, "guestfs_tune2fs_l: failed to parse reply error"); + return; + } + goto done; + } + if (!xdr_guestfs_tune2fs_l_ret (xdr, &rv->ret)) { + error (g, "guestfs_tune2fs_l: failed to parse reply"); + return; + } + done: + rv->cb_done = 1; + main_loop.main_loop_quit (g); +} + +char **guestfs_tune2fs_l (guestfs_h *g, + const char *device) +{ + struct guestfs_tune2fs_l_args args; + struct tune2fs_l_rv rv; + int serial; + + if (g->state != READY) { + error (g, "guestfs_tune2fs_l called from the wrong state, %d != READY", + g->state); + return NULL; + } + + memset (&rv, 0, sizeof rv); + + args.device = (char *) device; + serial = dispatch (g, GUESTFS_PROC_TUNE2FS_L, + (xdrproc_t) xdr_guestfs_tune2fs_l_args, (char *) &args); + if (serial == -1) + return NULL; + + rv.cb_done = 0; + g->reply_cb_internal = tune2fs_l_cb; + g->reply_cb_internal_data = &rv; + main_loop.main_loop_run (g); + g->reply_cb_internal = NULL; + g->reply_cb_internal_data = NULL; + if (!rv.cb_done) { + error (g, "guestfs_tune2fs_l failed, see earlier error messages"); + return NULL; + } + + if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_TUNE2FS_L, serial) == -1) + return NULL; + + if (rv.hdr.status == GUESTFS_STATUS_ERROR) { + error (g, "%s", rv.err.error); + return NULL; + } + + /* caller will free this, but we need to add a NULL entry */ + rv.ret.superblock.superblock_val = safe_realloc (g, rv.ret.superblock.superblock_val, + sizeof (char *) * (rv.ret.superblock.superblock_len + 1)); + rv.ret.superblock.superblock_val[rv.ret.superblock.superblock_len] = NULL; + return rv.ret.superblock.superblock_val; +} + diff --git a/src/guestfs-actions.h b/src/guestfs-actions.h index a838a0497..5f523c342 100644 --- a/src/guestfs-actions.h +++ b/src/guestfs-actions.h @@ -85,3 +85,4 @@ extern char **guestfs_command_lines (guestfs_h *handle, char * const* const argu extern struct guestfs_stat *guestfs_stat (guestfs_h *handle, const char *path); extern struct guestfs_stat *guestfs_lstat (guestfs_h *handle, const char *path); extern struct guestfs_statvfs *guestfs_statvfs (guestfs_h *handle, const char *path); +extern char **guestfs_tune2fs_l (guestfs_h *handle, const char *device); diff --git a/src/guestfs_protocol.c b/src/guestfs_protocol.c index 99377b4d6..33de1dc10 100644 --- a/src/guestfs_protocol.c +++ b/src/guestfs_protocol.c @@ -1013,6 +1013,27 @@ xdr_guestfs_statvfs_ret (XDR *xdrs, guestfs_statvfs_ret *objp) return TRUE; } +bool_t +xdr_guestfs_tune2fs_l_args (XDR *xdrs, guestfs_tune2fs_l_args *objp) +{ + register int32_t *buf; + + if (!xdr_string (xdrs, &objp->device, ~0)) + return FALSE; + return TRUE; +} + +bool_t +xdr_guestfs_tune2fs_l_ret (XDR *xdrs, guestfs_tune2fs_l_ret *objp) +{ + register int32_t *buf; + + if (!xdr_array (xdrs, (char **)&objp->superblock.superblock_val, (u_int *) &objp->superblock.superblock_len, ~0, + sizeof (str), (xdrproc_t) xdr_str)) + return FALSE; + return TRUE; +} + bool_t xdr_guestfs_procedure (XDR *xdrs, guestfs_procedure *objp) { diff --git a/src/guestfs_protocol.h b/src/guestfs_protocol.h index 072072372..270571e5c 100644 --- a/src/guestfs_protocol.h +++ b/src/guestfs_protocol.h @@ -527,6 +527,19 @@ struct guestfs_statvfs_ret { }; typedef struct guestfs_statvfs_ret guestfs_statvfs_ret; +struct guestfs_tune2fs_l_args { + char *device; +}; +typedef struct guestfs_tune2fs_l_args guestfs_tune2fs_l_args; + +struct guestfs_tune2fs_l_ret { + struct { + u_int superblock_len; + str *superblock_val; + } superblock; +}; +typedef struct guestfs_tune2fs_l_ret guestfs_tune2fs_l_ret; + enum guestfs_procedure { GUESTFS_PROC_MOUNT = 1, GUESTFS_PROC_SYNC = 2, @@ -582,7 +595,8 @@ enum guestfs_procedure { GUESTFS_PROC_STAT = 52, GUESTFS_PROC_LSTAT = 53, GUESTFS_PROC_STATVFS = 54, - GUESTFS_PROC_dummy = 54 + 1, + GUESTFS_PROC_TUNE2FS_L = 55, + GUESTFS_PROC_dummy = 55 + 1, }; typedef enum guestfs_procedure guestfs_procedure; #define GUESTFS_MESSAGE_MAX 4194304 @@ -696,6 +710,8 @@ extern bool_t xdr_guestfs_lstat_args (XDR *, guestfs_lstat_args*); extern bool_t xdr_guestfs_lstat_ret (XDR *, guestfs_lstat_ret*); extern bool_t xdr_guestfs_statvfs_args (XDR *, guestfs_statvfs_args*); extern bool_t xdr_guestfs_statvfs_ret (XDR *, guestfs_statvfs_ret*); +extern bool_t xdr_guestfs_tune2fs_l_args (XDR *, guestfs_tune2fs_l_args*); +extern bool_t xdr_guestfs_tune2fs_l_ret (XDR *, guestfs_tune2fs_l_ret*); extern bool_t xdr_guestfs_procedure (XDR *, guestfs_procedure*); extern bool_t xdr_guestfs_message_direction (XDR *, guestfs_message_direction*); extern bool_t xdr_guestfs_message_status (XDR *, guestfs_message_status*); @@ -779,6 +795,8 @@ extern bool_t xdr_guestfs_lstat_args (); extern bool_t xdr_guestfs_lstat_ret (); extern bool_t xdr_guestfs_statvfs_args (); extern bool_t xdr_guestfs_statvfs_ret (); +extern bool_t xdr_guestfs_tune2fs_l_args (); +extern bool_t xdr_guestfs_tune2fs_l_ret (); extern bool_t xdr_guestfs_procedure (); extern bool_t xdr_guestfs_message_direction (); extern bool_t xdr_guestfs_message_status (); diff --git a/src/guestfs_protocol.x b/src/guestfs_protocol.x index e03aef66e..1b6e71758 100644 --- a/src/guestfs_protocol.x +++ b/src/guestfs_protocol.x @@ -406,6 +406,14 @@ struct guestfs_statvfs_ret { guestfs_int_statvfs statbuf; }; +struct guestfs_tune2fs_l_args { + string device<>; +}; + +struct guestfs_tune2fs_l_ret { + str superblock<>; +}; + enum guestfs_procedure { GUESTFS_PROC_MOUNT = 1, GUESTFS_PROC_SYNC = 2, @@ -461,6 +469,7 @@ enum guestfs_procedure { GUESTFS_PROC_STAT = 52, GUESTFS_PROC_LSTAT = 53, GUESTFS_PROC_STATVFS = 54, + GUESTFS_PROC_TUNE2FS_L = 55, GUESTFS_PROC_dummy }; diff --git a/tests.c b/tests.c index 1c6676bd8..2791145ae 100644 --- a/tests.c +++ b/tests.c @@ -45,6 +45,14 @@ static void print_strings (char * const * const argv) printf ("\t%s\n", argv[argc]); } +static void print_table (char * const * const argv) +{ + int i; + + for (i = 0; argv[i] != NULL; i += 2) + printf ("%s: %s\n", argv[i], argv[i+1]); +} + static int test_mount_0 (void) { /* InitEmpty for mount (0) */