X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=src%2Fgenerator.ml;h=d680d42459671bf5d18cc9be18a58348206e9865;hp=06a638e62e8bd45654b720257e39844dae66f342;hb=abb447c32abdea467374edc30704818dd2883da7;hpb=99f68f259f92eee884c6c7396f61b9c16e2bf354

diff --git a/src/generator.ml b/src/generator.ml
index 06a638e..d680d42 100755
--- a/src/generator.ml
+++ b/src/generator.ml
@@ -33,6 +33,7 @@
  *)
 
 #load "unix.cma";;
+#load "str.cma";;
 
 open Printf
 
@@ -43,9 +44,15 @@ and ret =
      *)
   | RErr
     (* "RInt" as a return value means an int which is -1 for error
-     * or any value >= 0 on success.
+     * or any value >= 0 on success.  Only use this for smallish
+     * positive ints (0 <= i < 2^30).
      *)
   | RInt of string
+    (* "RInt64" is the same as RInt, but is guaranteed to be able
+     * to return a full 64 bit value, _except_ that -1 means error
+     * (so -1 cannot be a valid, non-error return value).
+     *)
+  | RInt64 of string
     (* "RBool" is a bool return value which can be true/false or
      * -1 for error.
      *)
@@ -65,6 +72,18 @@ and ret =
   | RPVList of string
   | RVGList of string
   | RLVList of string
+    (* Stat buffers. *)
+  | RStat of string
+  | RStatVFS of string
+    (* Key-value pairs of untyped strings.  Turns into a hashtable or
+     * dictionary in languages which support it.  DON'T use this as a
+     * general "bucket" for results.  Prefer a stronger typed return
+     * value if one is available, or write a custom struct.  Don't use
+     * this if the list could potentially be very long, since it is
+     * inefficient.  Keys should be unique.  NULLs are not permitted.
+     *)
+  | RHashtable of string
+
 and args = argt list	(* Function parameters, guestfs handle is implicit. *)
 
     (* Note in future we should allow a "variable args" parameter as
@@ -77,77 +96,117 @@ and args = argt list	(* Function parameters, guestfs handle is implicit. *)
 and argt =
   | String of string	(* const char *name, cannot be NULL *)
   | OptString of string	(* const char *name, may be NULL *)
+  | StringList of string(* list of strings (each string cannot be NULL) *)
   | Bool of string	(* boolean *)
   | Int of string	(* int (smallish ints, signed, <= 31 bits) *)
+    (* These are treated as filenames (simple string parameters) in
+     * the C API and bindings.  But in the RPC protocol, we transfer
+     * the actual file content up to or down from the daemon.
+     * FileIn: local machine -> daemon (in request)
+     * FileOut: daemon -> local machine (in reply)
+     * In guestfish (only), the special name "-" means read from
+     * stdin or write to stdout.
+     *)
+  | FileIn of string
+  | FileOut of string
 
 type flags =
   | ProtocolLimitWarning  (* display warning about protocol size limits *)
+  | DangerWillRobinson	  (* flags particularly dangerous commands *)
   | FishAlias of string	  (* provide an alias for this cmd in guestfish *)
   | FishAction of string  (* call this function in guestfish *)
   | NotInFish		  (* do not export via guestfish *)
 
+let protocol_limit_warning =
+  "Because of the message protocol, there is a transfer limit 
+of somewhere between 2MB and 4MB.  To transfer large files you should use
+FTP."
+
+let danger_will_robinson =
+  "B<This command is dangerous.  Without careful use you
+can easily destroy all your data>."
+
 (* You can supply zero or as many tests as you want per API call.
  *
- * Note that the test environment has 3 block devices, of size 10M, 20M
- * and 30M (respectively /dev/sda, /dev/sdb, /dev/sdc).  To run the
- * tests in a reasonable amount of time, the virtual machine and
- * block devices are reused between tests. So don't try testing
- * kill_subprocess :-x
+ * Note that the test environment has 3 block devices, of size 500MB,
+ * 50MB and 10MB (respectively /dev/sda, /dev/sdb, /dev/sdc).
+ * Note for partitioning purposes, the 500MB device has 63 cylinders.
+ *
+ * To be able to run the tests in a reasonable amount of time,
+ * the virtual machine and block devices are reused between tests.
+ * So don't try testing kill_subprocess :-x
+ *
+ * Between each test we umount-all and lvm-remove-all (except InitNone).
  *
  * Don't assume anything about the previous contents of the block
  * devices.  Use 'Init*' to create some initial scenarios.
  *)
-type tests = test list
+type tests = (test_init * test) list
 and test =
     (* Run the command sequence and just expect nothing to fail. *)
-  | TestRun of test_init * seq
+  | TestRun of seq
     (* Run the command sequence and expect the output of the final
      * command to be the string.
      *)
-  | TestOutput of test_init * seq * string
+  | TestOutput of seq * string
     (* Run the command sequence and expect the output of the final
      * command to be the list of strings.
      *)
-  | TestOutputList of test_init * seq * string list
+  | TestOutputList of seq * string list
     (* Run the command sequence and expect the output of the final
      * command to be the integer.
      *)
-  | TestOutputInt of test_init * seq * int
+  | TestOutputInt of seq * int
     (* Run the command sequence and expect the output of the final
      * command to be a true value (!= 0 or != NULL).
      *)
-  | TestOutputTrue of test_init * seq
+  | TestOutputTrue of seq
     (* Run the command sequence and expect the output of the final
      * command to be a false value (== 0 or == NULL, but not an error).
      *)
-  | TestOutputFalse of test_init * seq
+  | TestOutputFalse of seq
     (* Run the command sequence and expect the output of the final
      * command to be a list of the given length (but don't care about
      * content).
      *)
-  | TestOutputLength of test_init * seq * int
+  | TestOutputLength of seq * int
+    (* Run the command sequence and expect the output of the final
+     * command to be a structure.
+     *)
+  | TestOutputStruct of seq * test_field_compare list
     (* Run the command sequence and expect the final command (only)
      * to fail.
      *)
-  | TestLastFail of test_init * seq
+  | TestLastFail of seq
+
+and test_field_compare =
+  | CompareWithInt of string * int
+  | CompareWithString of string * string
+  | CompareFieldsIntEq of string * string
+  | CompareFieldsStrEq of string * string
 
 (* Some initial scenarios for testing. *)
 and test_init =
-    (* Do nothing, block devices could contain random stuff. *)
+    (* Do nothing, block devices could contain random stuff including
+     * LVM PVs, and some filesystems might be mounted.  This is usually
+     * a bad idea.
+     *)
   | InitNone
+    (* Block devices are empty and no filesystems are mounted. *)
+  | InitEmpty
     (* /dev/sda contains a single partition /dev/sda1, which is formatted
      * as ext2, empty [except for lost+found] and mounted on /.
      * /dev/sdb and /dev/sdc may have random content.
      * No LVM.
      *)
-  | InitEmpty
+  | InitBasicFS
     (* /dev/sda:
      *   /dev/sda1 (is a PV):
-     *     /dev/VG/LV:
+     *     /dev/VG/LV (size 8MB):
      *       formatted as ext2, empty [except for lost+found], mounted on /
      * /dev/sdb and /dev/sdc may have random content.
      *)
-  | InitEmptyLVM
+  | InitBasicFSonLVM
 
 (* Sequence of commands for testing. *)
 and seq = cmd list
@@ -226,6 +285,32 @@ The first character of C<param> string must be a C<-> (dash).
 
 C<value> can be NULL.");
 
+  ("set_qemu", (RErr, [String "qemu"]), -1, [FishAlias "qemu"],
+   [],
+   "set the qemu binary",
+   "\
+Set the qemu binary that we will use.
+
+The default is chosen when the library was compiled by the
+configure script.
+
+You can also override this by setting the C<LIBGUESTFS_QEMU>
+environment variable.
+
+The string C<qemu> is stashed in the libguestfs handle, so the caller
+must make sure it remains valid for the lifetime of the handle.
+
+Setting C<qemu> to C<NULL> restores the default qemu binary.");
+
+  ("get_qemu", (RConstString "qemu", []), -1, [],
+   [],
+   "get the qemu binary",
+   "\
+Return the current qemu binary.
+
+This is always non-NULL.  If it wasn't set already, then this will
+return the default qemu binary name.");
+
   ("set_path", (RErr, [String "path"]), -1, [FishAlias "path"],
    [],
    "set the search path",
@@ -276,14 +361,77 @@ C<LIBGUESTFS_DEBUG> is defined and set to C<1>.");
    [],
    "get verbose mode",
    "\
-This returns the verbose messages flag.")
+This returns the verbose messages flag.");
+
+  ("is_ready", (RBool "ready", []), -1, [],
+   [],
+   "is ready to accept commands",
+   "\
+This returns true iff this handle is ready to accept commands
+(in the C<READY> state).
+
+For more information on states, see L<guestfs(3)>.");
+
+  ("is_config", (RBool "config", []), -1, [],
+   [],
+   "is in configuration state",
+   "\
+This returns true iff this handle is being configured
+(in the C<CONFIG> state).
+
+For more information on states, see L<guestfs(3)>.");
+
+  ("is_launching", (RBool "launching", []), -1, [],
+   [],
+   "is launching subprocess",
+   "\
+This returns true iff this handle is launching the subprocess
+(in the C<LAUNCHING> state).
+
+For more information on states, see L<guestfs(3)>.");
+
+  ("is_busy", (RBool "busy", []), -1, [],
+   [],
+   "is busy processing a command",
+   "\
+This returns true iff this handle is busy processing a command
+(in the C<BUSY> state).
+
+For more information on states, see L<guestfs(3)>.");
+
+  ("get_state", (RInt "state", []), -1, [],
+   [],
+   "get the current state",
+   "\
+This returns the current state as an opaque integer.  This is
+only useful for printing debug and internal error messages.
+
+For more information on states, see L<guestfs(3)>.");
+
+  ("set_busy", (RErr, []), -1, [NotInFish],
+   [],
+   "set state to busy",
+   "\
+This sets the state to C<BUSY>.  This is only used when implementing
+actions using the low-level API.
+
+For more information on states, see L<guestfs(3)>.");
+
+  ("set_ready", (RErr, []), -1, [NotInFish],
+   [],
+   "set state to ready",
+   "\
+This sets the state to C<READY>.  This is only used when implementing
+actions using the low-level API.
+
+For more information on states, see L<guestfs(3)>.");
+
 ]
 
 let daemon_functions = [
   ("mount", (RErr, [String "device"; String "mountpoint"]), 1, [],
-   [TestOutput (
-      InitNone,
-      [["sfdisk"];
+   [InitEmpty, TestOutput (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
        ["mkfs"; "ext2"; "/dev/sda1"];
        ["mount"; "/dev/sda1"; "/"];
        ["write_file"; "/new"; "new file contents"; "0"];
@@ -308,7 +456,7 @@ The filesystem options C<sync> and C<noatime> are set with this
 call, in order to improve reliability.");
 
   ("sync", (RErr, []), 2, [],
-   [ TestRun (InitNone, [["sync"]])],
+   [ InitEmpty, TestRun [["sync"]]],
    "sync disks, writes are flushed through to the disk image",
    "\
 This syncs the disk, so that any writes are flushed through to the
@@ -318,8 +466,7 @@ You should always call this if you have modified a disk image, before
 closing the handle.");
 
   ("touch", (RErr, [String "path"]), 3, [],
-   [TestOutputTrue (
-      InitEmpty,
+   [InitBasicFS, TestOutputTrue (
       [["touch"; "/new"];
        ["exists"; "/new"]])],
    "update file timestamps or create a new file",
@@ -329,8 +476,7 @@ update the timestamps on a file, or, if the file does not exist,
 to create a new zero-length file.");
 
   ("cat", (RString "content", [String "path"]), 4, [ProtocolLimitWarning],
-   [TestOutput (
-      InitEmpty,
+   [InitBasicFS, TestOutput (
       [["write_file"; "/new"; "new file contents"; "0"];
        ["cat"; "/new"]], "new file contents")],
    "list the contents of a file",
@@ -339,7 +485,7 @@ Return the contents of the file named C<path>.
 
 Note that this function cannot correctly handle binary files
 (specifically, files containing C<\\0> character which is treated
-as end of string).  For those you need to use the C<guestfs_read_file>
+as end of string).  For those you need to use the C<guestfs_download>
 function which has a more complex interface.");
 
   ("ll", (RString "listing", [String "directory"]), 5, [],
@@ -355,8 +501,7 @@ This command is mostly useful for interactive sessions.  It
 is I<not> intended that you try to parse the output string.");
 
   ("ls", (RStringList "listing", [String "directory"]), 6, [],
-   [TestOutputList (
-      InitEmpty,
+   [InitBasicFS, TestOutputList (
       [["touch"; "/new"];
        ["touch"; "/newer"];
        ["touch"; "/newest"];
@@ -371,8 +516,7 @@ This command is mostly useful for interactive sessions.  Programs
 should probably use C<guestfs_readdir> instead.");
 
   ("list_devices", (RStringList "devices", []), 7, [],
-   [TestOutputList (
-      InitNone,
+   [InitEmpty, TestOutputList (
       [["list_devices"]], ["/dev/sda"; "/dev/sdb"; "/dev/sdc"])],
    "list the block devices",
    "\
@@ -381,12 +525,10 @@ List all the block devices.
 The full block device names are returned, eg. C</dev/sda>");
 
   ("list_partitions", (RStringList "partitions", []), 8, [],
-   [TestOutputList (
-      InitEmpty,
+   [InitBasicFS, TestOutputList (
       [["list_partitions"]], ["/dev/sda1"]);
-    TestOutputList (
-      InitEmpty,
-      [["sfdisk"];
+    InitEmpty, TestOutputList (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
        ["list_partitions"]], ["/dev/sda1"; "/dev/sda2"; "/dev/sda3"])],
    "list the partitions",
    "\
@@ -398,12 +540,10 @@ This does not return logical volumes.  For that you will need to
 call C<guestfs_lvs>.");
 
   ("pvs", (RStringList "physvols", []), 9, [],
-   [TestOutputList (
-      InitEmptyLVM,
+   [InitBasicFSonLVM, TestOutputList (
       [["pvs"]], ["/dev/sda1"]);
-    TestOutputList (
-      InitNone,
-      [["sfdisk"];
+    InitEmpty, TestOutputList (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
        ["pvcreate"; "/dev/sda1"];
        ["pvcreate"; "/dev/sda2"];
        ["pvcreate"; "/dev/sda3"];
@@ -419,12 +559,10 @@ PVs (eg. C</dev/sda2>).
 See also C<guestfs_pvs_full>.");
 
   ("vgs", (RStringList "volgroups", []), 10, [],
-   [TestOutputList (
-      InitEmptyLVM,
+   [InitBasicFSonLVM, TestOutputList (
       [["vgs"]], ["VG"]);
-    TestOutputList (
-      InitNone,
-      [["sfdisk"];
+    InitEmpty, TestOutputList (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
        ["pvcreate"; "/dev/sda1"];
        ["pvcreate"; "/dev/sda2"];
        ["pvcreate"; "/dev/sda3"];
@@ -442,21 +580,19 @@ detected (eg. C<VolGroup00>).
 See also C<guestfs_vgs_full>.");
 
   ("lvs", (RStringList "logvols", []), 11, [],
-   [TestOutputList (
-      InitEmptyLVM,
+   [InitBasicFSonLVM, TestOutputList (
       [["lvs"]], ["/dev/VG/LV"]);
-    TestOutputList (
-      InitNone,
-      [["sfdisk"];
+    InitEmpty, TestOutputList (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
        ["pvcreate"; "/dev/sda1"];
        ["pvcreate"; "/dev/sda2"];
        ["pvcreate"; "/dev/sda3"];
        ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
        ["vgcreate"; "VG2"; "/dev/sda3"];
-       ["lvcreate"; "LV1"; "VG1"; "5000"];
-       ["lvcreate"; "LV2"; "VG1"; "5000"];
-       ["lvcreate"; "LV3"; "VG2"; "5000"];
-       ["lvs"]], ["LV1"; "LV2"; "LV3"])],
+       ["lvcreate"; "LV1"; "VG1"; "50"];
+       ["lvcreate"; "LV2"; "VG1"; "50"];
+       ["lvcreate"; "LV3"; "VG2"; "50"];
+       ["lvs"]], ["/dev/VG1/LV1"; "/dev/VG1/LV2"; "/dev/VG2/LV3"])],
    "list the LVM logical volumes (LVs)",
    "\
 List all the logical volumes detected.  This is the equivalent
@@ -468,39 +604,31 @@ This returns a list of the logical volume device names
 See also C<guestfs_lvs_full>.");
 
   ("pvs_full", (RPVList "physvols", []), 12, [],
-   [TestOutputLength (
-      InitEmptyLVM,
-      [["pvs"]], 1)],
+   [], (* XXX how to test? *)
    "list the LVM physical volumes (PVs)",
    "\
 List all the physical volumes detected.  This is the equivalent
 of the L<pvs(8)> command.  The \"full\" version includes all fields.");
 
   ("vgs_full", (RVGList "volgroups", []), 13, [],
-   [TestOutputLength (
-      InitEmptyLVM,
-      [["pvs"]], 1)],
+   [], (* XXX how to test? *)
    "list the LVM volume groups (VGs)",
    "\
 List all the volumes groups detected.  This is the equivalent
 of the L<vgs(8)> command.  The \"full\" version includes all fields.");
 
   ("lvs_full", (RLVList "logvols", []), 14, [],
-   [TestOutputLength (
-      InitEmptyLVM,
-      [["pvs"]], 1)],
+   [], (* XXX how to test? *)
    "list the LVM logical volumes (LVs)",
    "\
 List all the logical volumes detected.  This is the equivalent
 of the L<lvs(8)> command.  The \"full\" version includes all fields.");
 
   ("read_lines", (RStringList "lines", [String "path"]), 15, [],
-   [TestOutputList (
-      InitEmpty,
+   [InitBasicFS, TestOutputList (
       [["write_file"; "/new"; "line1\r\nline2\nline3"; "0"];
        ["read_lines"; "/new"]], ["line1"; "line2"; "line3"]);
-    TestOutputList (
-      InitEmpty,
+    InitBasicFS, TestOutputList (
       [["write_file"; "/new"; ""; "0"];
        ["read_lines"; "/new"]], [])],
    "read file as lines",
@@ -675,45 +803,38 @@ This is just a shortcut for listing C<guestfs_aug_match>
 C<path/*> and sorting the resulting nodes into alphabetical order.");
 
   ("rm", (RErr, [String "path"]), 29, [],
-   [TestRun (
-      InitEmpty,
+   [InitBasicFS, TestRun
       [["touch"; "/new"];
-       ["rm"; "/new"]]);
-    TestLastFail (
-      InitEmpty,
-      [["rm"; "/new"]]);
-    TestLastFail (
-      InitEmpty,
+       ["rm"; "/new"]];
+    InitBasicFS, TestLastFail
+      [["rm"; "/new"]];
+    InitBasicFS, TestLastFail
       [["mkdir"; "/new"];
-       ["rm"; "/new"]])],
+       ["rm"; "/new"]]],
    "remove a file",
    "\
 Remove the single file C<path>.");
 
   ("rmdir", (RErr, [String "path"]), 30, [],
-   [TestRun (
-      InitEmpty,
+   [InitBasicFS, TestRun
       [["mkdir"; "/new"];
-       ["rmdir"; "/new"]]);
-    TestLastFail (
-      InitEmpty,
-      [["rmdir"; "/new"]]);
-    TestLastFail (
-      InitEmpty,
+       ["rmdir"; "/new"]];
+    InitBasicFS, TestLastFail
+      [["rmdir"; "/new"]];
+    InitBasicFS, TestLastFail
       [["touch"; "/new"];
-       ["rmdir"; "/new"]])],
+       ["rmdir"; "/new"]]],
    "remove a directory",
    "\
 Remove the single directory C<path>.");
 
   ("rm_rf", (RErr, [String "path"]), 31, [],
-   [TestOutputFalse (
-      InitEmpty,
+   [InitBasicFS, TestOutputFalse
       [["mkdir"; "/new"];
        ["mkdir"; "/new/foo"];
        ["touch"; "/new/foo/bar"];
        ["rm_rf"; "/new"];
-       ["exists"; "/new"]])],
+       ["exists"; "/new"]]],
    "remove a file or directory recursively",
    "\
 Remove the file or directory C<path>, recursively removing the
@@ -721,27 +842,25 @@ contents if its a directory.  This is like the C<rm -rf> shell
 command.");
 
   ("mkdir", (RErr, [String "path"]), 32, [],
-   [TestOutputTrue (
-      InitEmpty,
+   [InitBasicFS, TestOutputTrue
       [["mkdir"; "/new"];
-       ["is_dir"; "/new"]])],
+       ["is_dir"; "/new"]];
+    InitBasicFS, TestLastFail
+      [["mkdir"; "/new/foo/bar"]]],
    "create a directory",
    "\
 Create a directory named C<path>.");
 
   ("mkdir_p", (RErr, [String "path"]), 33, [],
-   [TestOutputTrue (
-      InitEmpty,
+   [InitBasicFS, TestOutputTrue
       [["mkdir_p"; "/new/foo/bar"];
-       ["is_dir"; "/new/foo/bar"]]);
-    TestOutputTrue (
-      InitEmpty,
+       ["is_dir"; "/new/foo/bar"]];
+    InitBasicFS, TestOutputTrue
       [["mkdir_p"; "/new/foo/bar"];
-       ["is_dir"; "/new/foo"]]);
-    TestOutputTrue (
-      InitEmpty,
+       ["is_dir"; "/new/foo"]];
+    InitBasicFS, TestOutputTrue
       [["mkdir_p"; "/new/foo/bar"];
-       ["is_dir"; "/new"]])],
+       ["is_dir"; "/new"]]],
    "create a directory and parents",
    "\
 Create a directory named C<path>, creating any parent directories
@@ -763,6 +882,738 @@ Change the file owner to C<owner> and group to C<group>.
 Only numeric uid and gid are supported.  If you want to use
 names, you will need to locate and parse the password file
 yourself (Augeas support makes this relatively easy).");
+
+  ("exists", (RBool "existsflag", [String "path"]), 36, [],
+   [InitBasicFS, TestOutputTrue (
+      [["touch"; "/new"];
+       ["exists"; "/new"]]);
+    InitBasicFS, TestOutputTrue (
+      [["mkdir"; "/new"];
+       ["exists"; "/new"]])],
+   "test if file or directory exists",
+   "\
+This returns C<true> if and only if there is a file, directory
+(or anything) with the given C<path> name.
+
+See also C<guestfs_is_file>, C<guestfs_is_dir>, C<guestfs_stat>.");
+
+  ("is_file", (RBool "fileflag", [String "path"]), 37, [],
+   [InitBasicFS, TestOutputTrue (
+      [["touch"; "/new"];
+       ["is_file"; "/new"]]);
+    InitBasicFS, TestOutputFalse (
+      [["mkdir"; "/new"];
+       ["is_file"; "/new"]])],
+   "test if file exists",
+   "\
+This returns C<true> if and only if there is a file
+with the given C<path> name.  Note that it returns false for
+other objects like directories.
+
+See also C<guestfs_stat>.");
+
+  ("is_dir", (RBool "dirflag", [String "path"]), 38, [],
+   [InitBasicFS, TestOutputFalse (
+      [["touch"; "/new"];
+       ["is_dir"; "/new"]]);
+    InitBasicFS, TestOutputTrue (
+      [["mkdir"; "/new"];
+       ["is_dir"; "/new"]])],
+   "test if file exists",
+   "\
+This returns C<true> if and only if there is a directory
+with the given C<path> name.  Note that it returns false for
+other objects like files.
+
+See also C<guestfs_stat>.");
+
+  ("pvcreate", (RErr, [String "device"]), 39, [],
+   [InitEmpty, TestOutputList (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
+       ["pvcreate"; "/dev/sda1"];
+       ["pvcreate"; "/dev/sda2"];
+       ["pvcreate"; "/dev/sda3"];
+       ["pvs"]], ["/dev/sda1"; "/dev/sda2"; "/dev/sda3"])],
+   "create an LVM physical volume",
+   "\
+This creates an LVM physical volume on the named C<device>,
+where C<device> should usually be a partition name such
+as C</dev/sda1>.");
+
+  ("vgcreate", (RErr, [String "volgroup"; StringList "physvols"]), 40, [],
+   [InitEmpty, TestOutputList (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
+       ["pvcreate"; "/dev/sda1"];
+       ["pvcreate"; "/dev/sda2"];
+       ["pvcreate"; "/dev/sda3"];
+       ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
+       ["vgcreate"; "VG2"; "/dev/sda3"];
+       ["vgs"]], ["VG1"; "VG2"])],
+   "create an LVM volume group",
+   "\
+This creates an LVM volume group called C<volgroup>
+from the non-empty list of physical volumes C<physvols>.");
+
+  ("lvcreate", (RErr, [String "logvol"; String "volgroup"; Int "mbytes"]), 41, [],
+   [InitEmpty, TestOutputList (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ",10 ,20 ,"];
+       ["pvcreate"; "/dev/sda1"];
+       ["pvcreate"; "/dev/sda2"];
+       ["pvcreate"; "/dev/sda3"];
+       ["vgcreate"; "VG1"; "/dev/sda1 /dev/sda2"];
+       ["vgcreate"; "VG2"; "/dev/sda3"];
+       ["lvcreate"; "LV1"; "VG1"; "50"];
+       ["lvcreate"; "LV2"; "VG1"; "50"];
+       ["lvcreate"; "LV3"; "VG2"; "50"];
+       ["lvcreate"; "LV4"; "VG2"; "50"];
+       ["lvcreate"; "LV5"; "VG2"; "50"];
+       ["lvs"]],
+      ["/dev/VG1/LV1"; "/dev/VG1/LV2";
+       "/dev/VG2/LV3"; "/dev/VG2/LV4"; "/dev/VG2/LV5"])],
+   "create an LVM volume group",
+   "\
+This creates an LVM volume group called C<logvol>
+on the volume group C<volgroup>, with C<size> megabytes.");
+
+  ("mkfs", (RErr, [String "fstype"; String "device"]), 42, [],
+   [InitEmpty, TestOutput (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
+       ["mkfs"; "ext2"; "/dev/sda1"];
+       ["mount"; "/dev/sda1"; "/"];
+       ["write_file"; "/new"; "new file contents"; "0"];
+       ["cat"; "/new"]], "new file contents")],
+   "make a filesystem",
+   "\
+This creates a filesystem on C<device> (usually a partition
+of LVM logical volume).  The filesystem type is C<fstype>, for
+example C<ext3>.");
+
+  ("sfdisk", (RErr, [String "device";
+		     Int "cyls"; Int "heads"; Int "sectors";
+		     StringList "lines"]), 43, [DangerWillRobinson],
+   [],
+   "create partitions on a block device",
+   "\
+This is a direct interface to the L<sfdisk(8)> program for creating
+partitions on block devices.
+
+C<device> should be a block device, for example C</dev/sda>.
+
+C<cyls>, C<heads> and C<sectors> are the number of cylinders, heads
+and sectors on the device, which are passed directly to sfdisk as
+the I<-C>, I<-H> and I<-S> parameters.  If you pass C<0> for any
+of these, then the corresponding parameter is omitted.  Usually for
+'large' disks, you can just pass C<0> for these, but for small
+(floppy-sized) disks, sfdisk (or rather, the kernel) cannot work
+out the right geometry and you will need to tell it.
+
+C<lines> is a list of lines that we feed to C<sfdisk>.  For more
+information refer to the L<sfdisk(8)> manpage.
+
+To create a single partition occupying the whole disk, you would
+pass C<lines> as a single element list, when the single element being
+the string C<,> (comma).");
+
+  ("write_file", (RErr, [String "path"; String "content"; Int "size"]), 44, [ProtocolLimitWarning],
+   [InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "new file contents"; "0"];
+       ["cat"; "/new"]], "new file contents");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "\nnew file contents\n"; "0"];
+       ["cat"; "/new"]], "\nnew file contents\n");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "\n\n"; "0"];
+       ["cat"; "/new"]], "\n\n");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; ""; "0"];
+       ["cat"; "/new"]], "");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "\n\n\n"; "0"];
+       ["cat"; "/new"]], "\n\n\n");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "\n"; "0"];
+       ["cat"; "/new"]], "\n")],
+   "create a file",
+   "\
+This call creates a file called C<path>.  The contents of the
+file is the string C<content> (which can contain any 8 bit data),
+with length C<size>.
+
+As a special case, if C<size> is C<0>
+then the length is calculated using C<strlen> (so in this case
+the content cannot contain embedded ASCII NULs).");
+
+  ("umount", (RErr, [String "pathordevice"]), 45, [FishAlias "unmount"],
+   [InitEmpty, TestOutputList (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
+       ["mkfs"; "ext2"; "/dev/sda1"];
+       ["mount"; "/dev/sda1"; "/"];
+       ["mounts"]], ["/dev/sda1"]);
+    InitEmpty, TestOutputList (
+      [["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
+       ["mkfs"; "ext2"; "/dev/sda1"];
+       ["mount"; "/dev/sda1"; "/"];
+       ["umount"; "/"];
+       ["mounts"]], [])],
+   "unmount a filesystem",
+   "\
+This unmounts the given filesystem.  The filesystem may be
+specified either by its mountpoint (path) or the device which
+contains the filesystem.");
+
+  ("mounts", (RStringList "devices", []), 46, [],
+   [InitBasicFS, TestOutputList (
+      [["mounts"]], ["/dev/sda1"])],
+   "show mounted filesystems",
+   "\
+This returns the list of currently mounted filesystems.  It returns
+the list of devices (eg. C</dev/sda1>, C</dev/VG/LV>).
+
+Some internal mounts are not shown.");
+
+  ("umount_all", (RErr, []), 47, [FishAlias "unmount-all"],
+   [InitBasicFS, TestOutputList (
+      [["umount_all"];
+       ["mounts"]], [])],
+   "unmount all filesystems",
+   "\
+This unmounts all mounted filesystems.
+
+Some internal mounts are not unmounted by this call.");
+
+  ("lvm_remove_all", (RErr, []), 48, [DangerWillRobinson],
+   [],
+   "remove all LVM LVs, VGs and PVs",
+   "\
+This command removes all LVM logical volumes, volume groups
+and physical volumes.");
+
+  ("file", (RString "description", [String "path"]), 49, [],
+   [InitBasicFS, TestOutput (
+      [["touch"; "/new"];
+       ["file"; "/new"]], "empty");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "some content\n"; "0"];
+       ["file"; "/new"]], "ASCII text");
+    InitBasicFS, TestLastFail (
+      [["file"; "/nofile"]])],
+   "determine file type",
+   "\
+This call uses the standard L<file(1)> command to determine
+the type or contents of the file.  This also works on devices,
+for example to find out whether a partition contains a filesystem.
+
+The exact command which runs is C<file -bsL path>.  Note in
+particular that the filename is not prepended to the output
+(the C<-b> option).");
+
+  ("command", (RString "output", [StringList "arguments"]), 50, [],
+   [], (* XXX how to test? *)
+   "run a command from the guest filesystem",
+   "\
+This call runs a command from the guest filesystem.  The
+filesystem must be mounted, and must contain a compatible
+operating system (ie. something Linux, with the same
+or compatible processor architecture).
+
+The single parameter is an argv-style list of arguments.
+The first element is the name of the program to run.
+Subsequent elements are parameters.  The list must be
+non-empty (ie. must contain a program name).
+
+The C<$PATH> environment variable will contain at least
+C</usr/bin> and C</bin>.  If you require a program from
+another location, you should provide the full path in the
+first parameter.
+
+Shared libraries and data files required by the program
+must be available on filesystems which are mounted in the
+correct places.  It is the caller's responsibility to ensure
+all filesystems that are needed are mounted at the right
+locations.");
+
+  ("command_lines", (RStringList "lines", [StringList "arguments"]), 51, [],
+   [], (* XXX how to test? *)
+   "run a command, returning lines",
+   "\
+This is the same as C<guestfs_command>, but splits the
+result into a list of lines.");
+
+  ("stat", (RStat "statbuf", [String "path"]), 52, [],
+   [InitBasicFS, TestOutputStruct (
+      [["touch"; "/new"];
+       ["stat"; "/new"]], [CompareWithInt ("size", 0)])],
+   "get file information",
+   "\
+Returns file information for the given C<path>.
+
+This is the same as the C<stat(2)> system call.");
+
+  ("lstat", (RStat "statbuf", [String "path"]), 53, [],
+   [InitBasicFS, TestOutputStruct (
+      [["touch"; "/new"];
+       ["lstat"; "/new"]], [CompareWithInt ("size", 0)])],
+   "get file information for a symbolic link",
+   "\
+Returns file information for the given C<path>.
+
+This is the same as C<guestfs_stat> except that if C<path>
+is a symbolic link, then the link is stat-ed, not the file it
+refers to.
+
+This is the same as the C<lstat(2)> system call.");
+
+  ("statvfs", (RStatVFS "statbuf", [String "path"]), 54, [],
+   [InitBasicFS, TestOutputStruct (
+      [["statvfs"; "/"]], [CompareWithInt ("bfree", 487702);
+			   CompareWithInt ("blocks", 490020);
+			   CompareWithInt ("bsize", 1024)])],
+   "get file system statistics",
+   "\
+Returns file system statistics for any mounted file system.
+C<path> should be a file or directory in the mounted file system
+(typically it is the mount point itself, but it doesn't need to be).
+
+This is the same as the C<statvfs(2)> system call.");
+
+  ("tune2fs_l", (RHashtable "superblock", [String "device"]), 55, [],
+   [], (* XXX test *)
+   "get ext2/ext3/ext4 superblock details",
+   "\
+This returns the contents of the ext2, ext3 or ext4 filesystem
+superblock on C<device>.
+
+It is the same as running C<tune2fs -l device>.  See L<tune2fs(8)>
+manpage for more details.  The list of fields returned isn't
+clearly defined, and depends on both the version of C<tune2fs>
+that libguestfs was built against, and the filesystem itself.");
+
+  ("blockdev_setro", (RErr, [String "device"]), 56, [],
+   [InitEmpty, TestOutputTrue (
+      [["blockdev_setro"; "/dev/sda"];
+       ["blockdev_getro"; "/dev/sda"]])],
+   "set block device to read-only",
+   "\
+Sets the block device named C<device> to read-only.
+
+This uses the L<blockdev(8)> command.");
+
+  ("blockdev_setrw", (RErr, [String "device"]), 57, [],
+   [InitEmpty, TestOutputFalse (
+      [["blockdev_setrw"; "/dev/sda"];
+       ["blockdev_getro"; "/dev/sda"]])],
+   "set block device to read-write",
+   "\
+Sets the block device named C<device> to read-write.
+
+This uses the L<blockdev(8)> command.");
+
+  ("blockdev_getro", (RBool "ro", [String "device"]), 58, [],
+   [InitEmpty, TestOutputTrue (
+      [["blockdev_setro"; "/dev/sda"];
+       ["blockdev_getro"; "/dev/sda"]])],
+   "is block device set to read-only",
+   "\
+Returns a boolean indicating if the block device is read-only
+(true if read-only, false if not).
+
+This uses the L<blockdev(8)> command.");
+
+  ("blockdev_getss", (RInt "sectorsize", [String "device"]), 59, [],
+   [InitEmpty, TestOutputInt (
+      [["blockdev_getss"; "/dev/sda"]], 512)],
+   "get sectorsize of block device",
+   "\
+This returns the size of sectors on a block device.
+Usually 512, but can be larger for modern devices.
+
+(Note, this is not the size in sectors, use C<guestfs_blockdev_getsz>
+for that).
+
+This uses the L<blockdev(8)> command.");
+
+  ("blockdev_getbsz", (RInt "blocksize", [String "device"]), 60, [],
+   [InitEmpty, TestOutputInt (
+      [["blockdev_getbsz"; "/dev/sda"]], 4096)],
+   "get blocksize of block device",
+   "\
+This returns the block size of a device.
+
+(Note this is different from both I<size in blocks> and
+I<filesystem block size>).
+
+This uses the L<blockdev(8)> command.");
+
+  ("blockdev_setbsz", (RErr, [String "device"; Int "blocksize"]), 61, [],
+   [], (* XXX test *)
+   "set blocksize of block device",
+   "\
+This sets the block size of a device.
+
+(Note this is different from both I<size in blocks> and
+I<filesystem block size>).
+
+This uses the L<blockdev(8)> command.");
+
+  ("blockdev_getsz", (RInt64 "sizeinsectors", [String "device"]), 62, [],
+   [InitEmpty, TestOutputInt (
+      [["blockdev_getsz"; "/dev/sda"]], 1024000)],
+   "get total size of device in 512-byte sectors",
+   "\
+This returns the size of the device in units of 512-byte sectors
+(even if the sectorsize isn't 512 bytes ... weird).
+
+See also C<guestfs_blockdev_getss> for the real sector size of
+the device, and C<guestfs_blockdev_getsize64> for the more
+useful I<size in bytes>.
+
+This uses the L<blockdev(8)> command.");
+
+  ("blockdev_getsize64", (RInt64 "sizeinbytes", [String "device"]), 63, [],
+   [InitEmpty, TestOutputInt (
+      [["blockdev_getsize64"; "/dev/sda"]], 524288000)],
+   "get total size of device in bytes",
+   "\
+This returns the size of the device in bytes.
+
+See also C<guestfs_blockdev_getsz>.
+
+This uses the L<blockdev(8)> command.");
+
+  ("blockdev_flushbufs", (RErr, [String "device"]), 64, [],
+   [InitEmpty, TestRun
+      [["blockdev_flushbufs"; "/dev/sda"]]],
+   "flush device buffers",
+   "\
+This tells the kernel to flush internal buffers associated
+with C<device>.
+
+This uses the L<blockdev(8)> command.");
+
+  ("blockdev_rereadpt", (RErr, [String "device"]), 65, [],
+   [InitEmpty, TestRun
+      [["blockdev_rereadpt"; "/dev/sda"]]],
+   "reread partition table",
+   "\
+Reread the partition table on C<device>.
+
+This uses the L<blockdev(8)> command.");
+
+  ("upload", (RErr, [FileIn "filename"; String "remotefilename"]), 66, [],
+   [InitBasicFS, TestOutput (
+      (* Pick a file from cwd which isn't likely to change. *)
+    [["upload"; "COPYING.LIB"; "/COPYING.LIB"];
+     ["checksum"; "md5"; "/COPYING.LIB"]], "e3eda01d9815f8d24aae2dbd89b68b06")],
+   "upload a file from the local machine",
+   "\
+Upload local file C<filename> to C<remotefilename> on the
+filesystem.
+
+C<filename> can also be a named pipe.
+
+See also C<guestfs_download>.");
+
+  ("download", (RErr, [String "remotefilename"; FileOut "filename"]), 67, [],
+   [InitBasicFS, TestOutput (
+      (* Pick a file from cwd which isn't likely to change. *)
+    [["upload"; "COPYING.LIB"; "/COPYING.LIB"];
+     ["download"; "/COPYING.LIB"; "testdownload.tmp"];
+     ["upload"; "testdownload.tmp"; "/upload"];
+     ["checksum"; "md5"; "/upload"]], "e3eda01d9815f8d24aae2dbd89b68b06")],
+   "download a file to the local machine",
+   "\
+Download file C<remotefilename> and save it as C<filename>
+on the local machine.
+
+C<filename> can also be a named pipe.
+
+See also C<guestfs_upload>, C<guestfs_cat>.");
+
+  ("checksum", (RString "checksum", [String "csumtype"; String "path"]), 68, [],
+   [InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "test\n"; "0"];
+       ["checksum"; "crc"; "/new"]], "935282863");
+    InitBasicFS, TestLastFail (
+      [["checksum"; "crc"; "/new"]]);
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "test\n"; "0"];
+       ["checksum"; "md5"; "/new"]], "d8e8fca2dc0f896fd7cb4cb0031ba249");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "test\n"; "0"];
+       ["checksum"; "sha1"; "/new"]], "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "test\n"; "0"];
+       ["checksum"; "sha224"; "/new"]], "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "test\n"; "0"];
+       ["checksum"; "sha256"; "/new"]], "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "test\n"; "0"];
+       ["checksum"; "sha384"; "/new"]], "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d");
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "test\n"; "0"];
+       ["checksum"; "sha512"; "/new"]], "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123")],
+   "compute MD5, SHAx or CRC checksum of file",
+   "\
+This call computes the MD5, SHAx or CRC checksum of the
+file named C<path>.
+
+The type of checksum to compute is given by the C<csumtype>
+parameter which must have one of the following values:
+
+=over 4
+
+=item C<crc>
+
+Compute the cyclic redundancy check (CRC) specified by POSIX
+for the C<cksum> command.
+
+=item C<md5>
+
+Compute the MD5 hash (using the C<md5sum> program).
+
+=item C<sha1>
+
+Compute the SHA1 hash (using the C<sha1sum> program).
+
+=item C<sha224>
+
+Compute the SHA224 hash (using the C<sha224sum> program).
+
+=item C<sha256>
+
+Compute the SHA256 hash (using the C<sha256sum> program).
+
+=item C<sha384>
+
+Compute the SHA384 hash (using the C<sha384sum> program).
+
+=item C<sha512>
+
+Compute the SHA512 hash (using the C<sha512sum> program).
+
+=back
+
+The checksum is returned as a printable string.");
+
+  ("tar_in", (RErr, [FileIn "tarfile"; String "directory"]), 69, [],
+   [InitBasicFS, TestOutput (
+      [["tar_in"; "images/helloworld.tar"; "/"];
+       ["cat"; "/hello"]], "hello\n")],
+   "unpack tarfile to directory",
+   "\
+This command uploads and unpacks local file C<tarfile> (an
+I<uncompressed> tar file) into C<directory>.
+
+To upload a compressed tarball, use C<guestfs_tgz_in>.");
+
+  ("tar_out", (RErr, [String "directory"; FileOut "tarfile"]), 70, [],
+   [],
+   "pack directory into tarfile",
+   "\
+This command packs the contents of C<directory> and downloads
+it to local file C<tarfile>.
+
+To download a compressed tarball, use C<guestfs_tgz_out>.");
+
+  ("tgz_in", (RErr, [FileIn "tarball"; String "directory"]), 71, [],
+   [InitBasicFS, TestOutput (
+      [["tgz_in"; "images/helloworld.tar.gz"; "/"];
+       ["cat"; "/hello"]], "hello\n")],
+   "unpack compressed tarball to directory",
+   "\
+This command uploads and unpacks local file C<tarball> (a
+I<gzip compressed> tar file) into C<directory>.
+
+To upload an uncompressed tarball, use C<guestfs_tar_in>.");
+
+  ("tgz_out", (RErr, [String "directory"; FileOut "tarball"]), 72, [],
+   [],
+   "pack directory into compressed tarball",
+   "\
+This command packs the contents of C<directory> and downloads
+it to local file C<tarball>.
+
+To download an uncompressed tarball, use C<guestfs_tar_out>.");
+
+  ("mount_ro", (RErr, [String "device"; String "mountpoint"]), 73, [],
+   [InitBasicFS, TestLastFail (
+      [["umount"; "/"];
+       ["mount_ro"; "/dev/sda1"; "/"];
+       ["touch"; "/new"]]);
+    InitBasicFS, TestOutput (
+      [["write_file"; "/new"; "data"; "0"];
+       ["umount"; "/"];
+       ["mount_ro"; "/dev/sda1"; "/"];
+       ["cat"; "/new"]], "data")],
+   "mount a guest disk, read-only",
+   "\
+This is the same as the C<guestfs_mount> command, but it
+mounts the filesystem with the read-only (I<-o ro>) flag.");
+
+  ("mount_options", (RErr, [String "options"; String "device"; String "mountpoint"]), 74, [],
+   [],
+   "mount a guest disk with mount options",
+   "\
+This is the same as the C<guestfs_mount> command, but it
+allows you to set the mount options as for the
+L<mount(8)> I<-o> flag.");
+
+  ("mount_vfs", (RErr, [String "options"; String "vfstype"; String "device"; String "mountpoint"]), 75, [],
+   [],
+   "mount a guest disk with mount options and vfstype",
+   "\
+This is the same as the C<guestfs_mount> command, but it
+allows you to set both the mount options and the vfstype
+as for the L<mount(8)> I<-o> and I<-t> flags.");
+
+  ("debug", (RString "result", [String "subcmd"; StringList "extraargs"]), 76, [],
+   [],
+   "debugging and internals",
+   "\
+The C<guestfs_debug> command exposes some internals of
+C<guestfsd> (the guestfs daemon) that runs inside the
+qemu subprocess.
+
+There is no comprehensive help for this command.  You have
+to look at the file C<daemon/debug.c> in the libguestfs source
+to find out what you can do.");
+
+  ("lvremove", (RErr, [String "device"]), 77, [],
+   [InitEmpty, TestOutputList (
+      [["pvcreate"; "/dev/sda"];
+       ["vgcreate"; "VG"; "/dev/sda"];
+       ["lvcreate"; "LV1"; "VG"; "50"];
+       ["lvcreate"; "LV2"; "VG"; "50"];
+       ["lvremove"; "/dev/VG/LV1"];
+       ["lvs"]], ["/dev/VG/LV2"]);
+    InitEmpty, TestOutputList (
+      [["pvcreate"; "/dev/sda"];
+       ["vgcreate"; "VG"; "/dev/sda"];
+       ["lvcreate"; "LV1"; "VG"; "50"];
+       ["lvcreate"; "LV2"; "VG"; "50"];
+       ["lvremove"; "/dev/VG"];
+       ["lvs"]], []);
+    InitEmpty, TestOutputList (
+      [["pvcreate"; "/dev/sda"];
+       ["vgcreate"; "VG"; "/dev/sda"];
+       ["lvcreate"; "LV1"; "VG"; "50"];
+       ["lvcreate"; "LV2"; "VG"; "50"];
+       ["lvremove"; "/dev/VG"];
+       ["vgs"]], ["VG"])],
+   "remove an LVM logical volume",
+   "\
+Remove an LVM logical volume C<device>, where C<device> is
+the path to the LV, such as C</dev/VG/LV>.
+
+You can also remove all LVs in a volume group by specifying
+the VG name, C</dev/VG>.");
+
+  ("vgremove", (RErr, [String "vgname"]), 78, [],
+   [InitEmpty, TestOutputList (
+      [["pvcreate"; "/dev/sda"];
+       ["vgcreate"; "VG"; "/dev/sda"];
+       ["lvcreate"; "LV1"; "VG"; "50"];
+       ["lvcreate"; "LV2"; "VG"; "50"];
+       ["vgremove"; "VG"];
+       ["lvs"]], []);
+    InitEmpty, TestOutputList (
+      [["pvcreate"; "/dev/sda"];
+       ["vgcreate"; "VG"; "/dev/sda"];
+       ["lvcreate"; "LV1"; "VG"; "50"];
+       ["lvcreate"; "LV2"; "VG"; "50"];
+       ["vgremove"; "VG"];
+       ["vgs"]], [])],
+   "remove an LVM volume group",
+   "\
+Remove an LVM volume group C<vgname>, (for example C<VG>).
+
+This also forcibly removes all logical volumes in the volume
+group (if any).");
+
+  ("pvremove", (RErr, [String "device"]), 79, [],
+   [InitEmpty, TestOutputList (
+      [["pvcreate"; "/dev/sda"];
+       ["vgcreate"; "VG"; "/dev/sda"];
+       ["lvcreate"; "LV1"; "VG"; "50"];
+       ["lvcreate"; "LV2"; "VG"; "50"];
+       ["vgremove"; "VG"];
+       ["pvremove"; "/dev/sda"];
+       ["lvs"]], []);
+    InitEmpty, TestOutputList (
+      [["pvcreate"; "/dev/sda"];
+       ["vgcreate"; "VG"; "/dev/sda"];
+       ["lvcreate"; "LV1"; "VG"; "50"];
+       ["lvcreate"; "LV2"; "VG"; "50"];
+       ["vgremove"; "VG"];
+       ["pvremove"; "/dev/sda"];
+       ["vgs"]], []);
+    InitEmpty, TestOutputList (
+      [["pvcreate"; "/dev/sda"];
+       ["vgcreate"; "VG"; "/dev/sda"];
+       ["lvcreate"; "LV1"; "VG"; "50"];
+       ["lvcreate"; "LV2"; "VG"; "50"];
+       ["vgremove"; "VG"];
+       ["pvremove"; "/dev/sda"];
+       ["pvs"]], [])],
+   "remove an LVM physical volume",
+   "\
+This wipes a physical volume C<device> so that LVM will no longer
+recognise it.
+
+The implementation uses the C<pvremove> command which refuses to
+wipe physical volumes that contain any volume groups, so you have
+to remove those first.");
+
+  ("set_e2label", (RErr, [String "device"; String "label"]), 80, [],
+   [InitBasicFS, TestOutput (
+      [["set_e2label"; "/dev/sda1"; "testlabel"];
+       ["get_e2label"; "/dev/sda1"]], "testlabel")],
+   "set the ext2/3/4 filesystem label",
+   "\
+This sets the ext2/3/4 filesystem label of the filesystem on
+C<device> to C<label>.  Filesystem labels are limited to
+16 characters.
+
+You can use either C<guestfs_tune2fs_l> or C<guestfs_get_e2label>
+to return the existing label on a filesystem.");
+
+  ("get_e2label", (RString "label", [String "device"]), 81, [],
+   [],
+   "get the ext2/3/4 filesystem label",
+   "\
+This returns the ext2/3/4 filesystem label of the filesystem on
+C<device>.");
+
+  ("set_e2uuid", (RErr, [String "device"; String "uuid"]), 82, [],
+   [InitBasicFS, TestOutput (
+      [["set_e2uuid"; "/dev/sda1"; "a3a61220-882b-4f61-89f4-cf24dcc7297d"];
+       ["get_e2uuid"; "/dev/sda1"]], "a3a61220-882b-4f61-89f4-cf24dcc7297d");
+    InitBasicFS, TestOutput (
+      [["set_e2uuid"; "/dev/sda1"; "clear"];
+       ["get_e2uuid"; "/dev/sda1"]], "");
+    (* We can't predict what UUIDs will be, so just check the commands run. *)
+    InitBasicFS, TestRun (
+      [["set_e2uuid"; "/dev/sda1"; "random"]]);
+    InitBasicFS, TestRun (
+      [["set_e2uuid"; "/dev/sda1"; "time"]])],
+   "set the ext2/3/4 filesystem UUID",
+   "\
+This sets the ext2/3/4 filesystem UUID of the filesystem on
+C<device> to C<uuid>.  The format of the UUID and alternatives
+such as C<clear>, C<random> and C<time> are described in the
+L<tune2fs(8)> manpage.
+
+You can use either C<guestfs_tune2fs_l> or C<guestfs_get_e2uuid>
+to return the existing UUID of a filesystem.");
+
+  ("get_e2uuid", (RString "uuid", [String "device"]), 83, [],
+   [],
+   "get the ext2/3/4 filesystem UUID",
+   "\
+This returns the ext2/3/4 filesystem UUID of the filesystem on
+C<device>.");
+
 ]
 
 let all_functions = non_daemon_functions @ daemon_functions
@@ -837,6 +1688,39 @@ let lv_cols = [
   "modules", `String;
 ]
 
+(* Column names and types from stat structures.
+ * NB. Can't use things like 'st_atime' because glibc header files
+ * define some of these as macros.  Ugh.
+ *)
+let stat_cols = [
+  "dev", `Int;
+  "ino", `Int;
+  "mode", `Int;
+  "nlink", `Int;
+  "uid", `Int;
+  "gid", `Int;
+  "rdev", `Int;
+  "size", `Int;
+  "blksize", `Int;
+  "blocks", `Int;
+  "atime", `Int;
+  "mtime", `Int;
+  "ctime", `Int;
+]
+let statvfs_cols = [
+  "bsize", `Int;
+  "frsize", `Int;
+  "blocks", `Int;
+  "bfree", `Int;
+  "bavail", `Int;
+  "files", `Int;
+  "ffree", `Int;
+  "favail", `Int;
+  "fsid", `Int;
+  "flag", `Int;
+  "namemax", `Int;
+]
+
 (* Useful functions.
  * Note we don't want to use any external OCaml libraries which
  * makes this a bit harder than it should be.
@@ -854,8 +1738,33 @@ let replace_char s c1 c2 =
   done;
   if not !r then s else s2
 
-let rec find s sub =
-  let len = String.length s in
+let isspace c =
+  c = ' '
+  (* || c = '\f' *) || c = '\n' || c = '\r' || c = '\t' (* || c = '\v' *)
+
+let triml ?(test = isspace) str =
+  let i = ref 0 in
+  let n = ref (String.length str) in
+  while !n > 0 && test str.[!i]; do
+    decr n;
+    incr i
+  done;
+  if !i = 0 then str
+  else String.sub str !i !n
+
+let trimr ?(test = isspace) str =
+  let n = ref (String.length str) in
+  while !n > 0 && test str.[!n-1]; do
+    decr n
+  done;
+  if !n = String.length str then str
+  else String.sub str 0 !n
+
+let trim ?(test = isspace) str =
+  trimr ~test (triml ~test str)
+
+let rec find s sub =
+  let len = String.length s in
   let sublen = String.length sub in
   let rec loop i =
     if i <= len-sublen then (
@@ -884,6 +1793,17 @@ let rec replace_str s s1 s2 =
     s' ^ s2 ^ replace_str s'' s1 s2
   )
 
+let rec string_split sep str =
+  let len = String.length str in
+  let seplen = String.length sep in
+  let i = find str sep in
+  if i = -1 then [str]
+  else (
+    let s' = String.sub str 0 i in
+    let s'' = String.sub str (i+seplen) (len-i-seplen) in
+    s' :: string_split sep s''
+  )
+
 let rec find_map f = function
   | [] -> raise Not_found
   | x :: xs ->
@@ -898,7 +1818,22 @@ let iteri f xs =
   in
   loop 0 xs
 
-let name_of_argt = function String n | OptString n | Bool n | Int n -> n
+let mapi f xs =
+  let rec loop i = function
+    | [] -> []
+    | x :: xs -> let r = f i x in r :: loop (i+1) xs
+  in
+  loop 0 xs
+
+let name_of_argt = function
+  | String n | OptString n | StringList n | Bool n | Int n
+  | FileIn n | FileOut n -> n
+
+let seq_of_test = function
+  | TestRun s | TestOutput (s, _) | TestOutputList (s, _)
+  | TestOutputInt (s, _) | TestOutputTrue s | TestOutputFalse s
+  | TestOutputLength (s, _) | TestOutputStruct (s, _)
+  | TestLastFail s -> s
 
 (* Check function names etc. for consistency. *)
 let check_functions () =
@@ -938,13 +1873,17 @@ let check_functions () =
 	  failwithf "%s param/ret %s should not contain '-' or '_'"
 	    name n;
 	if n = "value" then
-	  failwithf "%s has a param/ret called 'value', which causes conflicts in the OCaml bindings, use something like 'val' or a more descriptive name" n
+	  failwithf "%s has a param/ret called 'value', which causes conflicts in the OCaml bindings, use something like 'val' or a more descriptive name" n;
+	if n = "argv" || n = "args" then
+	  failwithf "%s has a param/ret called 'argv' or 'args', which will cause some conflicts in the generated code" n
       in
 
       (match fst style with
        | RErr -> ()
-       | RInt n | RBool n | RConstString n | RString n
-       | RStringList n | RPVList n | RVGList n | RLVList n ->
+       | RInt n | RInt64 n | RBool n | RConstString n | RString n
+       | RStringList n | RPVList n | RVGList n | RLVList n
+       | RStat n | RStatVFS n
+       | RHashtable n ->
 	   check_arg_ret_name n
        | RIntBool (n,m) ->
 	   check_arg_ret_name n;
@@ -953,6 +1892,16 @@ let check_functions () =
       List.iter (fun arg -> check_arg_ret_name (name_of_argt arg)) (snd style)
   ) all_functions;
 
+  (* Check short descriptions. *)
+  List.iter (
+    fun (name, _, _, _, _, shortdesc, _) ->
+      if shortdesc.[0] <> Char.lowercase shortdesc.[0] then
+	failwithf "short description of %s should begin with lowercase." name;
+      let c = shortdesc.[String.length shortdesc-1] in
+      if c = '\n' || c = '.' then
+	failwithf "short description of %s should not end with . or \\n." name
+  ) all_functions;
+
   (* Check long dscriptions. *)
   List.iter (
     fun (name, _, _, _, _, _, longdesc) ->
@@ -987,7 +1936,31 @@ let check_functions () =
 	failwithf "%s and %s have conflicting procedure numbers (%d, %d)"
 	  name1 name2 nr1 nr2
   in
-  loop proc_nrs
+  loop proc_nrs;
+
+  (* Check tests. *)
+  List.iter (
+    function
+      (* Ignore functions that have no tests.  We generate a
+       * warning when the user does 'make check' instead.
+       *)
+    | name, _, _, _, [], _, _ -> ()
+    | name, _, _, _, tests, _, _ ->
+	let funcs =
+	  List.map (
+	    fun (_, test) ->
+	      match seq_of_test test with
+	      | [] ->
+		  failwithf "%s has a test containing an empty sequence" name
+	      | cmds -> List.map List.hd cmds
+	  ) tests in
+	let funcs = List.flatten funcs in
+
+	let tested = List.mem name funcs in
+
+	if not tested then
+	  failwithf "function %s has tests but does not test itself" name
+  ) all_functions
 
 (* 'pr' prints to the current output file. *)
 let chan = ref stdout
@@ -1063,35 +2036,60 @@ let rec generate_actions_pod () =
 	   pr "This function returns 0 on success or -1 on error.\n\n"
        | RInt _ ->
 	   pr "On error this function returns -1.\n\n"
+       | RInt64 _ ->
+	   pr "On error this function returns -1.\n\n"
        | RBool _ ->
 	   pr "This function returns a C truth value on success or -1 on error.\n\n"
        | RConstString _ ->
-	   pr "This function returns a string or NULL on error.
+	   pr "This function returns a string, or NULL on error.
 The string is owned by the guest handle and must I<not> be freed.\n\n"
        | RString _ ->
-	   pr "This function returns a string or NULL on error.
+	   pr "This function returns a string, or NULL on error.
 I<The caller must free the returned string after use>.\n\n"
        | RStringList _ ->
 	   pr "This function returns a NULL-terminated array of strings
 (like L<environ(3)>), or NULL if there was an error.
 I<The caller must free the strings and the array after use>.\n\n"
        | RIntBool _ ->
-	   pr "This function returns a C<struct guestfs_int_bool *>.
+	   pr "This function returns a C<struct guestfs_int_bool *>,
+or NULL if there was an error.
 I<The caller must call C<guestfs_free_int_bool> after use>.\n\n"
        | RPVList _ ->
-	   pr "This function returns a C<struct guestfs_lvm_pv_list *>.
+	   pr "This function returns a C<struct guestfs_lvm_pv_list *>
+(see E<lt>guestfs-structs.hE<gt>),
+or NULL if there was an error.
 I<The caller must call C<guestfs_free_lvm_pv_list> after use>.\n\n"
        | RVGList _ ->
-	   pr "This function returns a C<struct guestfs_lvm_vg_list *>.
+	   pr "This function returns a C<struct guestfs_lvm_vg_list *>
+(see E<lt>guestfs-structs.hE<gt>),
+or NULL if there was an error.
 I<The caller must call C<guestfs_free_lvm_vg_list> after use>.\n\n"
        | RLVList _ ->
-	   pr "This function returns a C<struct guestfs_lvm_lv_list *>.
+	   pr "This function returns a C<struct guestfs_lvm_lv_list *>
+(see E<lt>guestfs-structs.hE<gt>),
+or NULL if there was an error.
 I<The caller must call C<guestfs_free_lvm_lv_list> after use>.\n\n"
+       | RStat _ ->
+	   pr "This function returns a C<struct guestfs_stat *>
+(see L<stat(2)> and E<lt>guestfs-structs.hE<gt>),
+or NULL if there was an error.
+I<The caller must call C<free> after use>.\n\n"
+       | RStatVFS _ ->
+	   pr "This function returns a C<struct guestfs_statvfs *>
+(see L<statvfs(2)> and E<lt>guestfs-structs.hE<gt>),
+or NULL if there was an error.
+I<The caller must call C<free> after use>.\n\n"
+       | RHashtable _ ->
+	   pr "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<n> keys and values alternate, followed by the trailing NULL entry.
+I<The caller must free the strings and the array after use>.\n\n"
       );
       if List.mem ProtocolLimitWarning flags then
-	pr "Because of the message protocol, there is a transfer limit 
-of somewhere between 2MB and 4MB.  To transfer large files you should use
-FTP.\n\n";
+	pr "%s\n\n" protocol_limit_warning;
+      if List.mem DangerWillRobinson flags then
+	pr "%s\n\n" danger_will_robinson;
   ) all_functions_sorted
 
 and generate_structs_pod () =
@@ -1157,6 +2155,18 @@ and generate_xdr () =
 	pr "\n";
   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
 
+  (* Stat internal structures. *)
+  List.iter (
+    function
+    | typ, cols ->
+	pr "struct guestfs_int_%s {\n" typ;
+	List.iter (function
+		   | name, `Int -> pr "  hyper %s;\n" name
+		  ) cols;
+	pr "};\n";
+	pr "\n";
+  ) ["stat", stat_cols; "statvfs", statvfs_cols];
+
   List.iter (
     fun (shortname, style, _, _, _, _, _) ->
       let name = "guestfs_" ^ shortname in
@@ -1169,8 +2179,10 @@ and generate_xdr () =
 	     function
 	     | String n -> pr "  string %s<>;\n" n
 	     | OptString n -> pr "  str *%s;\n" n
+	     | StringList n -> pr "  str %s<>;\n" n
 	     | Bool n -> pr "  bool %s;\n" n
 	     | Int n -> pr "  int %s;\n" n
+	     | FileIn _ | FileOut _ -> ()
 	   ) args;
 	   pr "};\n\n"
       );
@@ -1180,6 +2192,10 @@ and generate_xdr () =
 	   pr "struct %s_ret {\n" name;
 	   pr "  int %s;\n" n;
 	   pr "};\n\n"
+       | RInt64 n ->
+	   pr "struct %s_ret {\n" name;
+	   pr "  hyper %s;\n" n;
+	   pr "};\n\n"
        | RBool n ->
 	   pr "struct %s_ret {\n" name;
 	   pr "  bool %s;\n" n;
@@ -1211,6 +2227,18 @@ and generate_xdr () =
 	   pr "struct %s_ret {\n" name;
 	   pr "  guestfs_lvm_int_lv_list %s;\n" n;
 	   pr "};\n\n"
+       | RStat n ->
+	   pr "struct %s_ret {\n" name;
+	   pr "  guestfs_int_stat %s;\n" n;
+	   pr "};\n\n"
+       | RStatVFS n ->
+	   pr "struct %s_ret {\n" name;
+	   pr "  guestfs_int_statvfs %s;\n" n;
+	   pr "};\n\n"
+       | RHashtable n ->
+	   pr "struct %s_ret {\n" name;
+	   pr "  str %s<>;\n" n;
+	   pr "};\n\n"
       );
   ) daemon_functions;
 
@@ -1220,7 +2248,7 @@ and generate_xdr () =
     fun (shortname, _, proc_nr, _, _, _, _) ->
       pr "  GUESTFS_PROC_%s = %d,\n" (String.uppercase shortname) proc_nr
   ) daemon_functions;
-  pr "  GUESTFS_PROC_dummy\n"; (* so we don't have a "hanging comma" *)
+  pr "  GUESTFS_PROC_NR_PROCS\n";
   pr "};\n";
   pr "\n";
 
@@ -1235,9 +2263,17 @@ and generate_xdr () =
 
   (* Message header, etc. *)
   pr "\
+/* The communication protocol is now documented in the guestfs(3)
+ * manpage.
+ */
+
 const GUESTFS_PROGRAM = 0x2000F5F5;
 const GUESTFS_PROTOCOL_VERSION = 1;
 
+/* These constants must be larger than any possible message length. */
+const GUESTFS_LAUNCH_FLAG = 0xf5f55ff5;
+const GUESTFS_CANCEL_FLAG = 0xffffeeee;
+
 enum guestfs_message_direction {
   GUESTFS_DIRECTION_CALL = 0,        /* client -> daemon */
   GUESTFS_DIRECTION_REPLY = 1        /* daemon -> client */
@@ -1251,7 +2287,7 @@ enum guestfs_message_status {
 const GUESTFS_ERROR_LEN = 256;
 
 struct guestfs_message_error {
-  string error<GUESTFS_ERROR_LEN>;   /* error message */
+  string error_message<GUESTFS_ERROR_LEN>;
 };
 
 struct guestfs_message_header {
@@ -1262,6 +2298,14 @@ struct guestfs_message_header {
   unsigned serial;                   /* message serial number */
   guestfs_message_status status;
 };
+
+const GUESTFS_MAX_CHUNK_SIZE = 8192;
+
+struct guestfs_chunk {
+  int cancel;			     /* if non-zero, transfer is cancelled */
+  /* data size is 0 bytes if the transfer has finished successfully */
+  opaque data<GUESTFS_MAX_CHUNK_SIZE>;
+};
 "
 
 (* Generate the guestfs-structs.h file. *)
@@ -1309,7 +2353,20 @@ and generate_structs_h () =
 	pr "  struct guestfs_lvm_%s *val;\n" typ;
 	pr "};\n";
 	pr "\n"
-  ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols]
+  ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
+
+  (* Stat structures. *)
+  List.iter (
+    function
+    | typ, cols ->
+	pr "struct guestfs_%s {\n" typ;
+	List.iter (
+	  function
+	  | name, `Int -> pr "  int64_t %s;\n" name
+	) cols;
+	pr "};\n";
+	pr "\n"
+  ) ["stat", stat_cols; "statvfs", statvfs_cols]
 
 (* Generate the guestfs-actions.h file. *)
 and generate_actions_h () =
@@ -1325,40 +2382,127 @@ and generate_actions_h () =
 and generate_client_actions () =
   generate_header CStyle LGPLv2;
 
+  pr "\
+#include <stdio.h>
+#include <stdlib.h>
+
+#include \"guestfs.h\"
+#include \"guestfs_protocol.h\"
+
+#define error guestfs_error
+#define perrorf guestfs_perrorf
+#define safe_malloc guestfs_safe_malloc
+#define safe_realloc guestfs_safe_realloc
+#define safe_strdup guestfs_safe_strdup
+#define safe_memdup guestfs_safe_memdup
+
+/* Check the return message from a call for validity. */
+static int
+check_reply_header (guestfs_h *g,
+                    const struct guestfs_message_header *hdr,
+                    int proc_nr, int serial)
+{
+  if (hdr->prog != GUESTFS_PROGRAM) {
+    error (g, \"wrong program (%%d/%%d)\", hdr->prog, GUESTFS_PROGRAM);
+    return -1;
+  }
+  if (hdr->vers != GUESTFS_PROTOCOL_VERSION) {
+    error (g, \"wrong protocol version (%%d/%%d)\",
+	   hdr->vers, GUESTFS_PROTOCOL_VERSION);
+    return -1;
+  }
+  if (hdr->direction != GUESTFS_DIRECTION_REPLY) {
+    error (g, \"unexpected message direction (%%d/%%d)\",
+	   hdr->direction, GUESTFS_DIRECTION_REPLY);
+    return -1;
+  }
+  if (hdr->proc != proc_nr) {
+    error (g, \"unexpected procedure number (%%d/%%d)\", hdr->proc, proc_nr);
+    return -1;
+  }
+  if (hdr->serial != serial) {
+    error (g, \"unexpected serial (%%d/%%d)\", hdr->serial, serial);
+    return -1;
+  }
+
+  return 0;
+}
+
+/* Check we are in the right state to run a high-level action. */
+static int
+check_state (guestfs_h *g, const char *caller)
+{
+  if (!guestfs_is_ready (g)) {
+    if (guestfs_is_config (g))
+      error (g, \"%%s: call launch() before using this function\",
+        caller);
+    else if (guestfs_is_launching (g))
+      error (g, \"%%s: call wait_ready() before using this function\",
+        caller);
+    else
+      error (g, \"%%s called from the wrong state, %%d != READY\",
+        caller, guestfs_get_state (g));
+    return -1;
+  }
+  return 0;
+}
+
+";
+
   (* Client-side stubs for each function. *)
   List.iter (
     fun (shortname, style, _, _, _, _, _) ->
       let name = "guestfs_" ^ shortname in
 
-      (* Generate the return value struct. *)
-      pr "struct %s_rv {\n" shortname;
-      pr "  int cb_done;  /* flag to indicate callback was called */\n";
+      (* Generate the context struct which stores the high-level
+       * state between callback functions.
+       *)
+      pr "struct %s_ctx {\n" shortname;
+      pr "  /* This flag is set by the callbacks, so we know we've done\n";
+      pr "   * the callbacks as expected, and in the right sequence.\n";
+      pr "   * 0 = not called, 1 = reply_cb called.\n";
+      pr "   */\n";
+      pr "  int cb_sequence;\n";
       pr "  struct guestfs_message_header hdr;\n";
       pr "  struct guestfs_message_error err;\n";
       (match fst style with
        | RErr -> ()
        | RConstString _ ->
 	   failwithf "RConstString cannot be returned from a daemon function"
-       | RInt _
+       | RInt _ | RInt64 _
        | RBool _ | RString _ | RStringList _
        | RIntBool _
-       | RPVList _ | RVGList _ | RLVList _ ->
+       | RPVList _ | RVGList _ | RLVList _
+       | RStat _ | RStatVFS _
+       | RHashtable _ ->
 	   pr "  struct %s_ret ret;\n" name
       );
-      pr "};\n\n";
+      pr "};\n";
+      pr "\n";
 
-      (* Generate the callback function. *)
-      pr "static void %s_cb (guestfs_h *g, void *data, XDR *xdr)\n" shortname;
+      (* Generate the reply callback function. *)
+      pr "static void %s_reply_cb (guestfs_h *g, void *data, XDR *xdr)\n" shortname;
       pr "{\n";
-      pr "  struct %s_rv *rv = (struct %s_rv *) data;\n" shortname shortname;
+      pr "  guestfs_main_loop *ml = guestfs_get_main_loop (g);\n";
+      pr "  struct %s_ctx *ctx = (struct %s_ctx *) data;\n" shortname shortname;
+      pr "\n";
+      pr "  /* This should definitely not happen. */\n";
+      pr "  if (ctx->cb_sequence != 0) {\n";
+      pr "    ctx->cb_sequence = 9999;\n";
+      pr "    error (g, \"%%s: internal error: reply callback called twice\", \"%s\");\n" name;
+      pr "    return;\n";
+      pr "  }\n";
       pr "\n";
-      pr "  if (!xdr_guestfs_message_header (xdr, &rv->hdr)) {\n";
-      pr "    error (g, \"%s: failed to parse reply header\");\n" name;
+      pr "  ml->main_loop_quit (ml, g);\n";
+      pr "\n";
+      pr "  if (!xdr_guestfs_message_header (xdr, &ctx->hdr)) {\n";
+      pr "    error (g, \"%%s: failed to parse reply header\", \"%s\");\n" name;
       pr "    return;\n";
       pr "  }\n";
-      pr "  if (rv->hdr.status == GUESTFS_STATUS_ERROR) {\n";
-      pr "    if (!xdr_guestfs_message_error (xdr, &rv->err)) {\n";
-      pr "      error (g, \"%s: failed to parse reply error\");\n" name;
+      pr "  if (ctx->hdr.status == GUESTFS_STATUS_ERROR) {\n";
+      pr "    if (!xdr_guestfs_message_error (xdr, &ctx->err)) {\n";
+      pr "      error (g, \"%%s: failed to parse reply error\", \"%s\");\n"
+	name;
       pr "      return;\n";
       pr "    }\n";
       pr "    goto done;\n";
@@ -1368,19 +2512,20 @@ and generate_client_actions () =
        | RErr -> ()
        | RConstString _ ->
 	   failwithf "RConstString cannot be returned from a daemon function"
-       | RInt _
+       | RInt _ | RInt64 _
        | RBool _ | RString _ | RStringList _
        | RIntBool _
-       | RPVList _ | RVGList _ | RLVList _ ->
-	    pr "  if (!xdr_%s_ret (xdr, &rv->ret)) {\n" name;
-	    pr "    error (g, \"%s: failed to parse reply\");\n" name;
+       | RPVList _ | RVGList _ | RLVList _
+       | RStat _ | RStatVFS _
+       | RHashtable _ ->
+	    pr "  if (!xdr_%s_ret (xdr, &ctx->ret)) {\n" name;
+	    pr "    error (g, \"%%s: failed to parse reply\", \"%s\");\n" name;
 	    pr "    return;\n";
 	    pr "  }\n";
       );
 
       pr " done:\n";
-      pr "  rv->cb_done = 1;\n";
-      pr "  main_loop.main_loop_quit (g);\n";
+      pr "  ctx->cb_sequence = 1;\n";
       pr "}\n\n";
 
       (* Generate the action stub. *)
@@ -1389,11 +2534,13 @@ and generate_client_actions () =
 
       let error_code =
 	match fst style with
-	| RErr | RInt _ | RBool _ -> "-1"
+	| RErr | RInt _ | RInt64 _ | RBool _ -> "-1"
 	| RConstString _ ->
 	    failwithf "RConstString cannot be returned from a daemon function"
 	| RString _ | RStringList _ | RIntBool _
-	| RPVList _ | RVGList _ | RLVList _ ->
+	| RPVList _ | RVGList _ | RLVList _
+	| RStat _ | RStatVFS _
+	| RHashtable _ ->
 	    "NULL" in
 
       pr "{\n";
@@ -1403,22 +2550,20 @@ and generate_client_actions () =
        | _ -> pr "  struct %s_args args;\n" name
       );
 
-      pr "  struct %s_rv rv;\n" shortname;
+      pr "  struct %s_ctx ctx;\n" shortname;
+      pr "  guestfs_main_loop *ml = guestfs_get_main_loop (g);\n";
       pr "  int serial;\n";
       pr "\n";
-      pr "  if (g->state != READY) {\n";
-      pr "    error (g, \"%s called from the wrong state, %%d != READY\",\n"
-	name;
-      pr "      g->state);\n";
-      pr "    return %s;\n" error_code;
-      pr "  }\n";
+      pr "  if (check_state (g, \"%s\") == -1) return %s;\n" name error_code;
+      pr "  guestfs_set_busy (g);\n";
       pr "\n";
-      pr "  memset (&rv, 0, sizeof rv);\n";
+      pr "  memset (&ctx, 0, sizeof ctx);\n";
       pr "\n";
 
+      (* Send the main header and arguments. *)
       (match snd style with
        | [] ->
-	   pr "  serial = dispatch (g, GUESTFS_PROC_%s, NULL, NULL);\n"
+	   pr "  serial = guestfs__send_sync (g, GUESTFS_PROC_%s, NULL, NULL);\n"
 	     (String.uppercase shortname)
        | args ->
 	   List.iter (
@@ -1427,71 +2572,112 @@ and generate_client_actions () =
 		 pr "  args.%s = (char *) %s;\n" n n
 	     | OptString n ->
 		 pr "  args.%s = %s ? (char **) &%s : NULL;\n" n n n
+	     | StringList n ->
+		 pr "  args.%s.%s_val = (char **) %s;\n" n n n;
+		 pr "  for (args.%s.%s_len = 0; %s[args.%s.%s_len]; args.%s.%s_len++) ;\n" n n n n n n n;
 	     | Bool n ->
 		 pr "  args.%s = %s;\n" n n
 	     | Int n ->
 		 pr "  args.%s = %s;\n" n n
+	     | FileIn _ | FileOut _ -> ()
 	   ) args;
-	   pr "  serial = dispatch (g, GUESTFS_PROC_%s,\n"
+	   pr "  serial = guestfs__send_sync (g, GUESTFS_PROC_%s,\n"
 	     (String.uppercase shortname);
-	   pr "                     (xdrproc_t) xdr_%s_args, (char *) &args);\n"
+	   pr "        (xdrproc_t) xdr_%s_args, (char *) &args);\n"
 	     name;
       );
-      pr "  if (serial == -1)\n";
+      pr "  if (serial == -1) {\n";
+      pr "    guestfs_set_ready (g);\n";
       pr "    return %s;\n" error_code;
+      pr "  }\n";
       pr "\n";
 
-      pr "  rv.cb_done = 0;\n";
-      pr "  g->reply_cb_internal = %s_cb;\n" shortname;
-      pr "  g->reply_cb_internal_data = &rv;\n";
-      pr "  main_loop.main_loop_run (g);\n";
-      pr "  g->reply_cb_internal = NULL;\n";
-      pr "  g->reply_cb_internal_data = NULL;\n";
-      pr "  if (!rv.cb_done) {\n";
-      pr "    error (g, \"%s failed, see earlier error messages\");\n" name;
+      (* Send any additional files (FileIn) requested. *)
+      let need_read_reply_label = ref false in
+      List.iter (
+	function
+	| FileIn n ->
+	    pr "  {\n";
+	    pr "    int r;\n";
+	    pr "\n";
+	    pr "    r = guestfs__send_file_sync (g, %s);\n" n;
+	    pr "    if (r == -1) {\n";
+	    pr "      guestfs_set_ready (g);\n";
+	    pr "      return %s;\n" error_code;
+	    pr "    }\n";
+	    pr "    if (r == -2) /* daemon cancelled */\n";
+	    pr "      goto read_reply;\n";
+	    need_read_reply_label := true;
+	    pr "  }\n";
+	    pr "\n";
+	| _ -> ()
+      ) (snd style);
+
+      (* Wait for the reply from the remote end. *)
+      if !need_read_reply_label then pr " read_reply:\n";
+      pr "  guestfs__switch_to_receiving (g);\n";
+      pr "  ctx.cb_sequence = 0;\n";
+      pr "  guestfs_set_reply_callback (g, %s_reply_cb, &ctx);\n" shortname;
+      pr "  (void) ml->main_loop_run (ml, g);\n";
+      pr "  guestfs_set_reply_callback (g, NULL, NULL);\n";
+      pr "  if (ctx.cb_sequence != 1) {\n";
+      pr "    error (g, \"%%s reply failed, see earlier error messages\", \"%s\");\n" name;
+      pr "    guestfs_set_ready (g);\n";
       pr "    return %s;\n" error_code;
       pr "  }\n";
       pr "\n";
 
-      pr "  if (check_reply_header (g, &rv.hdr, GUESTFS_PROC_%s, serial) == -1)\n"
+      pr "  if (check_reply_header (g, &ctx.hdr, GUESTFS_PROC_%s, serial) == -1) {\n"
 	(String.uppercase shortname);
+      pr "    guestfs_set_ready (g);\n";
       pr "    return %s;\n" error_code;
+      pr "  }\n";
       pr "\n";
 
-      pr "  if (rv.hdr.status == GUESTFS_STATUS_ERROR) {\n";
-      pr "    error (g, \"%%s\", rv.err.error);\n";
+      pr "  if (ctx.hdr.status == GUESTFS_STATUS_ERROR) {\n";
+      pr "    error (g, \"%%s\", ctx.err.error_message);\n";
+      pr "    guestfs_set_ready (g);\n";
       pr "    return %s;\n" error_code;
       pr "  }\n";
       pr "\n";
 
+      (* Expecting to receive further files (FileOut)? *)
+      List.iter (
+	function
+	| FileOut n ->
+	    pr "  if (guestfs__receive_file_sync (g, %s) == -1) {\n" n;
+	    pr "    guestfs_set_ready (g);\n";
+	    pr "    return %s;\n" error_code;
+	    pr "  }\n";
+	    pr "\n";
+	| _ -> ()
+      ) (snd style);
+
+      pr "  guestfs_set_ready (g);\n";
+
       (match fst style with
        | RErr -> pr "  return 0;\n"
-       | RInt n
-       | RBool n -> pr "  return rv.ret.%s;\n" n
+       | RInt n | RInt64 n | RBool n ->
+	   pr "  return ctx.ret.%s;\n" n
        | RConstString _ ->
 	   failwithf "RConstString cannot be returned from a daemon function"
        | RString n ->
-	   pr "  return rv.ret.%s; /* caller will free */\n" n
-       | RStringList n ->
+	   pr "  return ctx.ret.%s; /* caller will free */\n" n
+       | RStringList n | RHashtable n ->
 	   pr "  /* caller will free this, but we need to add a NULL entry */\n";
-	   pr "  rv.ret.%s.%s_val =" n n;
-	   pr "    safe_realloc (g, rv.ret.%s.%s_val,\n" n n;
-	   pr "                  sizeof (char *) * (rv.ret.%s.%s_len + 1));\n"
+	   pr "  ctx.ret.%s.%s_val =\n" n n;
+	   pr "    safe_realloc (g, ctx.ret.%s.%s_val,\n" n n;
+	   pr "                  sizeof (char *) * (ctx.ret.%s.%s_len + 1));\n"
 	     n n;
-	   pr "  rv.ret.%s.%s_val[rv.ret.%s.%s_len] = NULL;\n" n n n n;
-	   pr "  return rv.ret.%s.%s_val;\n" n n
+	   pr "  ctx.ret.%s.%s_val[ctx.ret.%s.%s_len] = NULL;\n" n n n n;
+	   pr "  return ctx.ret.%s.%s_val;\n" n n
        | RIntBool _ ->
 	   pr "  /* caller with free this */\n";
-	   pr "  return safe_memdup (g, &rv.ret, sizeof (rv.ret));\n"
-       | RPVList n ->
-	   pr "  /* caller will free this */\n";
-	   pr "  return safe_memdup (g, &rv.ret.%s, sizeof (rv.ret.%s));\n" n n
-       | RVGList n ->
+	   pr "  return safe_memdup (g, &ctx.ret, sizeof (ctx.ret));\n"
+       | RPVList n | RVGList n | RLVList n
+       | RStat n | RStatVFS n ->
 	   pr "  /* caller will free this */\n";
-	   pr "  return safe_memdup (g, &rv.ret.%s, sizeof (rv.ret.%s));\n" n n
-       | RLVList n ->
-	   pr "  /* caller will free this */\n";
-	   pr "  return safe_memdup (g, &rv.ret.%s, sizeof (rv.ret.%s));\n" n n
+	   pr "  return safe_memdup (g, &ctx.ret.%s, sizeof (ctx.ret.%s));\n" n n
       );
 
       pr "}\n\n"
@@ -1515,7 +2701,7 @@ and generate_daemon_actions_h () =
 and generate_daemon_actions () =
   generate_header CStyle GPLv2;
 
-  pr "#define _GNU_SOURCE // for strchrnul\n";
+  pr "#include <config.h>\n";
   pr "\n";
   pr "#include <stdio.h>\n";
   pr "#include <stdlib.h>\n";
@@ -1538,15 +2724,18 @@ and generate_daemon_actions () =
       let error_code =
 	match fst style with
 	| RErr | RInt _ -> pr "  int r;\n"; "-1"
+	| RInt64 _ -> pr "  int64_t r;\n"; "-1"
 	| RBool _ -> pr "  int r;\n"; "-1"
 	| RConstString _ ->
 	    failwithf "RConstString cannot be returned from a daemon function"
 	| RString _ -> pr "  char *r;\n"; "NULL"
-	| RStringList _ -> pr "  char **r;\n"; "NULL"
+	| RStringList _ | RHashtable _ -> pr "  char **r;\n"; "NULL"
 	| RIntBool _ -> pr "  guestfs_%s_ret *r;\n" name; "NULL"
 	| RPVList _ -> pr "  guestfs_lvm_int_pv_list *r;\n"; "NULL"
 	| RVGList _ -> pr "  guestfs_lvm_int_vg_list *r;\n"; "NULL"
-	| RLVList _ -> pr "  guestfs_lvm_int_lv_list *r;\n"; "NULL" in
+	| RLVList _ -> pr "  guestfs_lvm_int_lv_list *r;\n"; "NULL"
+	| RStat _ -> pr "  guestfs_int_stat *r;\n"; "NULL"
+	| RStatVFS _ -> pr "  guestfs_int_statvfs *r;\n"; "NULL" in
 
       (match snd style with
        | [] -> ()
@@ -1556,8 +2745,10 @@ and generate_daemon_actions () =
 	     function
 	     | String n
 	     | OptString n -> pr "  const char *%s;\n" n
+	     | StringList n -> pr "  char **%s;\n" n
 	     | Bool n -> pr "  int %s;\n" n
 	     | Int n -> pr "  int %s;\n" n
+	     | FileIn _ | FileOut _ -> ()
 	   ) args
       );
       pr "\n";
@@ -1575,62 +2766,89 @@ and generate_daemon_actions () =
 	     function
 	     | String n -> pr "  %s = args.%s;\n" n n
 	     | OptString n -> pr "  %s = args.%s ? *args.%s : NULL;\n" n n n
+	     | StringList n ->
+		 pr "  %s = realloc (args.%s.%s_val,\n" n n n;
+		 pr "                sizeof (char *) * (args.%s.%s_len+1));\n" n n;
+		 pr "  if (%s == NULL) {\n" n;
+		 pr "    reply_with_perror (\"realloc\");\n";
+		 pr "    goto done;\n";
+		 pr "  }\n";
+		 pr "  %s[args.%s.%s_len] = NULL;\n" n n n;
+		 pr "  args.%s.%s_val = %s;\n" n n n;
 	     | Bool n -> pr "  %s = args.%s;\n" n n
 	     | Int n -> pr "  %s = args.%s;\n" n n
+	     | FileIn _ | FileOut _ -> ()
 	   ) args;
 	   pr "\n"
       );
 
+      (* Don't want to call the impl with any FileIn or FileOut
+       * parameters, since these go "outside" the RPC protocol.
+       *)
+      let argsnofile =
+	List.filter (function FileIn _ | FileOut _ -> false | _ -> true)
+	  (snd style) in
       pr "  r = do_%s " name;
-      generate_call_args style;
+      generate_call_args argsnofile;
       pr ";\n";
 
       pr "  if (r == %s)\n" error_code;
-      pr "    /* do_%s has already called reply_with_error, so just return */\n" name;
-      pr "    return;\n";
+      pr "    /* do_%s has already called reply_with_error */\n" name;
+      pr "    goto done;\n";
       pr "\n";
 
-      (match fst style with
-       | RErr -> pr "  reply (NULL, NULL);\n"
-       | RInt n ->
-	   pr "  struct guestfs_%s_ret ret;\n" name;
-	   pr "  ret.%s = r;\n" n;
-	   pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n" name
-       | RBool n ->
-	   pr "  struct guestfs_%s_ret ret;\n" name;
-	   pr "  ret.%s = r;\n" n;
-	   pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n" name
-       | RConstString _ ->
-	   failwithf "RConstString cannot be returned from a daemon function"
-       | RString n ->
-	   pr "  struct guestfs_%s_ret ret;\n" name;
-	   pr "  ret.%s = r;\n" n;
-	   pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n" name;
-	   pr "  free (r);\n"
-       | RStringList n ->
-	   pr "  struct guestfs_%s_ret ret;\n" name;
-	   pr "  ret.%s.%s_len = count_strings (r);\n" n n;
-	   pr "  ret.%s.%s_val = r;\n" n n;
-	   pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n" name;
-	   pr "  free_strings (r);\n"
-       | RIntBool _ ->
-	   pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) r);\n" name;
-	   pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) r);\n" name
-       | RPVList n ->
-	   pr "  struct guestfs_%s_ret ret;\n" name;
-	   pr "  ret.%s = *r;\n" n;
-	   pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name;
-	   pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name
-       | RVGList n ->
-	   pr "  struct guestfs_%s_ret ret;\n" name;
-	   pr "  ret.%s = *r;\n" n;
-	   pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name;
-	   pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name
-       | RLVList n ->
-	   pr "  struct guestfs_%s_ret ret;\n" name;
-	   pr "  ret.%s = *r;\n" n;
-	   pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name;
-	   pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n" name
+      (* If there are any FileOut parameters, then the impl must
+       * send its own reply.
+       *)
+      let no_reply =
+	List.exists (function FileOut _ -> true | _ -> false) (snd style) in
+      if no_reply then
+	pr "  /* do_%s has already sent a reply */\n" name
+      else (
+	match fst style with
+	| RErr -> pr "  reply (NULL, NULL);\n"
+	| RInt n | RInt64 n | RBool n ->
+	    pr "  struct guestfs_%s_ret ret;\n" name;
+	    pr "  ret.%s = r;\n" n;
+	    pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
+	      name
+	| RConstString _ ->
+	    failwithf "RConstString cannot be returned from a daemon function"
+	| RString n ->
+	    pr "  struct guestfs_%s_ret ret;\n" name;
+	    pr "  ret.%s = r;\n" n;
+	    pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
+	      name;
+	    pr "  free (r);\n"
+	| RStringList n | RHashtable n ->
+	    pr "  struct guestfs_%s_ret ret;\n" name;
+	    pr "  ret.%s.%s_len = count_strings (r);\n" n n;
+	    pr "  ret.%s.%s_val = r;\n" n n;
+	    pr "  reply ((xdrproc_t) &xdr_guestfs_%s_ret, (char *) &ret);\n"
+	      name;
+	    pr "  free_strings (r);\n"
+	| RIntBool _ ->
+	    pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) r);\n"
+	      name;
+	    pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) r);\n" name
+	| RPVList n | RVGList n | RLVList n
+	| RStat n | RStatVFS n ->
+	    pr "  struct guestfs_%s_ret ret;\n" name;
+	    pr "  ret.%s = *r;\n" n;
+	    pr "  reply ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n"
+	      name;
+	    pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_ret, (char *) &ret);\n"
+	      name
+      );
+
+      (* Free the args. *)
+      (match snd style with
+       | [] ->
+	   pr "done: ;\n";
+       | _ ->
+	   pr "done:\n";
+	   pr "  xdr_free ((xdrproc_t) xdr_guestfs_%s_args, (char *) &args);\n"
+	     name
       );
 
       pr "}\n\n";
@@ -1762,6 +2980,7 @@ and generate_daemon_actions () =
 	pr "    reply_with_error (\"%%s\", err);\n";
 	pr "    free (out);\n";
 	pr "    free (err);\n";
+	pr "    free (ret);\n";
 	pr "    return NULL;\n";
 	pr "  }\n";
 	pr "\n";
@@ -1823,20 +3042,535 @@ and generate_daemon_actions () =
 and generate_tests () =
   generate_header CStyle GPLv2;
 
-  pr "#include <stdio.h>\n";
-  pr "#include <stdlib.h>\n";
-  pr "#include <string.h>\n";
+  pr "\
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <fcntl.h>
+
+#include \"guestfs.h\"
+
+static guestfs_h *g;
+static int suppress_error = 0;
+
+static void print_error (guestfs_h *g, void *data, const char *msg)
+{
+  if (!suppress_error)
+    fprintf (stderr, \"%%s\\n\", msg);
+}
+
+static void print_strings (char * const * const argv)
+{
+  int argc;
+
+  for (argc = 0; argv[argc] != NULL; ++argc)
+    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 void no_test_warnings (void)
+{
+";
+
+  List.iter (
+    function
+    | name, _, _, _, [], _, _ ->
+	pr "  fprintf (stderr, \"warning: \\\"guestfs_%s\\\" has no tests\\n\");\n" name
+    | name, _, _, _, tests, _, _ -> ()
+  ) all_functions;
+
+  pr "}\n";
   pr "\n";
-  pr "#include \"guestfs.h\"\n";
+
+  (* Generate the actual tests.  Note that we generate the tests
+   * in reverse order, deliberately, so that (in general) the
+   * newest tests run first.  This makes it quicker and easier to
+   * debug them.
+   *)
+  let test_names =
+    List.map (
+      fun (name, _, _, _, tests, _, _) ->
+	mapi (generate_one_test name) tests
+    ) (List.rev all_functions) in
+  let test_names = List.concat test_names in
+  let nr_tests = List.length test_names in
+
+  pr "\
+int main (int argc, char *argv[])
+{
+  char c = 0;
+  int failed = 0;
+  const char *srcdir;
+  const char *filename;
+  int fd;
+  int nr_tests, test_num = 0;
+
+  no_test_warnings ();
+
+  g = guestfs_create ();
+  if (g == NULL) {
+    printf (\"guestfs_create FAILED\\n\");
+    exit (1);
+  }
+
+  guestfs_set_error_handler (g, print_error, NULL);
+
+  srcdir = getenv (\"srcdir\");
+  if (!srcdir) srcdir = \".\";
+  chdir (srcdir);
+  guestfs_set_path (g, \".\");
+
+  filename = \"test1.img\";
+  fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
+  if (fd == -1) {
+    perror (filename);
+    exit (1);
+  }
+  if (lseek (fd, %d, SEEK_SET) == -1) {
+    perror (\"lseek\");
+    close (fd);
+    unlink (filename);
+    exit (1);
+  }
+  if (write (fd, &c, 1) == -1) {
+    perror (\"write\");
+    close (fd);
+    unlink (filename);
+    exit (1);
+  }
+  if (close (fd) == -1) {
+    perror (filename);
+    unlink (filename);
+    exit (1);
+  }
+  if (guestfs_add_drive (g, filename) == -1) {
+    printf (\"guestfs_add_drive %%s FAILED\\n\", filename);
+    exit (1);
+  }
+
+  filename = \"test2.img\";
+  fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
+  if (fd == -1) {
+    perror (filename);
+    exit (1);
+  }
+  if (lseek (fd, %d, SEEK_SET) == -1) {
+    perror (\"lseek\");
+    close (fd);
+    unlink (filename);
+    exit (1);
+  }
+  if (write (fd, &c, 1) == -1) {
+    perror (\"write\");
+    close (fd);
+    unlink (filename);
+    exit (1);
+  }
+  if (close (fd) == -1) {
+    perror (filename);
+    unlink (filename);
+    exit (1);
+  }
+  if (guestfs_add_drive (g, filename) == -1) {
+    printf (\"guestfs_add_drive %%s FAILED\\n\", filename);
+    exit (1);
+  }
+
+  filename = \"test3.img\";
+  fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
+  if (fd == -1) {
+    perror (filename);
+    exit (1);
+  }
+  if (lseek (fd, %d, SEEK_SET) == -1) {
+    perror (\"lseek\");
+    close (fd);
+    unlink (filename);
+    exit (1);
+  }
+  if (write (fd, &c, 1) == -1) {
+    perror (\"write\");
+    close (fd);
+    unlink (filename);
+    exit (1);
+  }
+  if (close (fd) == -1) {
+    perror (filename);
+    unlink (filename);
+    exit (1);
+  }
+  if (guestfs_add_drive (g, filename) == -1) {
+    printf (\"guestfs_add_drive %%s FAILED\\n\", filename);
+    exit (1);
+  }
+
+  if (guestfs_launch (g) == -1) {
+    printf (\"guestfs_launch FAILED\\n\");
+    exit (1);
+  }
+  if (guestfs_wait_ready (g) == -1) {
+    printf (\"guestfs_wait_ready FAILED\\n\");
+    exit (1);
+  }
+
+  nr_tests = %d;
+
+" (500 * 1024 * 1024) (50 * 1024 * 1024) (10 * 1024 * 1024) nr_tests;
+
+  iteri (
+    fun i test_name ->
+      pr "  test_num++;\n";
+      pr "  printf (\"%%3d/%%3d %s\\n\", test_num, nr_tests);\n" test_name;
+      pr "  if (%s () == -1) {\n" test_name;
+      pr "    printf (\"%s FAILED\\n\");\n" test_name;
+      pr "    failed++;\n";
+      pr "  }\n";
+  ) test_names;
   pr "\n";
 
+  pr "  guestfs_close (g);\n";
+  pr "  unlink (\"test1.img\");\n";
+  pr "  unlink (\"test2.img\");\n";
+  pr "  unlink (\"test3.img\");\n";
+  pr "\n";
 
+  pr "  if (failed > 0) {\n";
+  pr "    printf (\"***** %%d / %%d tests FAILED *****\\n\", failed, nr_tests);\n";
+  pr "    exit (1);\n";
+  pr "  }\n";
+  pr "\n";
 
-  pr "int main (int argc, char *argv[])\n";
-  pr "{\n";
   pr "  exit (0);\n";
   pr "}\n"
 
+and generate_one_test name i (init, test) =
+  let test_name = sprintf "test_%s_%d" name i in
+
+  pr "static int %s (void)\n" test_name;
+  pr "{\n";
+
+  (match init with
+   | InitNone -> ()
+   | InitEmpty ->
+       pr "  /* InitEmpty for %s (%d) */\n" name i;
+       List.iter (generate_test_command_call test_name)
+	 [["umount_all"];
+	  ["lvm_remove_all"]]
+   | InitBasicFS ->
+       pr "  /* InitBasicFS for %s (%d): create ext2 on /dev/sda1 */\n" name i;
+       List.iter (generate_test_command_call test_name)
+	 [["umount_all"];
+	  ["lvm_remove_all"];
+	  ["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
+	  ["mkfs"; "ext2"; "/dev/sda1"];
+	  ["mount"; "/dev/sda1"; "/"]]
+   | InitBasicFSonLVM ->
+       pr "  /* InitBasicFSonLVM for %s (%d): create ext2 on /dev/VG/LV */\n"
+	 name i;
+       List.iter (generate_test_command_call test_name)
+	 [["umount_all"];
+	  ["lvm_remove_all"];
+	  ["sfdisk"; "/dev/sda"; "0"; "0"; "0"; ","];
+	  ["pvcreate"; "/dev/sda1"];
+	  ["vgcreate"; "VG"; "/dev/sda1"];
+	  ["lvcreate"; "LV"; "VG"; "8"];
+	  ["mkfs"; "ext2"; "/dev/VG/LV"];
+	  ["mount"; "/dev/VG/LV"; "/"]]
+  );
+
+  let get_seq_last = function
+    | [] ->
+	failwithf "%s: you cannot use [] (empty list) when expecting a command"
+	  test_name
+    | seq ->
+	let seq = List.rev seq in
+	List.rev (List.tl seq), List.hd seq
+  in
+
+  (match test with
+   | TestRun seq ->
+       pr "  /* TestRun for %s (%d) */\n" name i;
+       List.iter (generate_test_command_call test_name) seq
+   | TestOutput (seq, expected) ->
+       pr "  /* TestOutput for %s (%d) */\n" name i;
+       let seq, last = get_seq_last seq in
+       let test () =
+	 pr "    if (strcmp (r, \"%s\") != 0) {\n" (c_quote expected);
+	 pr "      fprintf (stderr, \"%s: expected \\\"%s\\\" but got \\\"%%s\\\"\\n\", r);\n" test_name (c_quote expected);
+	 pr "      return -1;\n";
+	 pr "    }\n"
+       in
+       List.iter (generate_test_command_call test_name) seq;
+       generate_test_command_call ~test test_name last
+   | TestOutputList (seq, expected) ->
+       pr "  /* TestOutputList for %s (%d) */\n" name i;
+       let seq, last = get_seq_last seq in
+       let test () =
+	 iteri (
+	   fun i str ->
+	     pr "    if (!r[%d]) {\n" i;
+	     pr "      fprintf (stderr, \"%s: short list returned from command\\n\");\n" test_name;
+	     pr "      print_strings (r);\n";
+	     pr "      return -1;\n";
+	     pr "    }\n";
+	     pr "    if (strcmp (r[%d], \"%s\") != 0) {\n" i (c_quote str);
+	     pr "      fprintf (stderr, \"%s: expected \\\"%s\\\" but got \\\"%%s\\\"\\n\", r[%d]);\n" test_name (c_quote str) i;
+	     pr "      return -1;\n";
+	     pr "    }\n"
+	 ) expected;
+	 pr "    if (r[%d] != NULL) {\n" (List.length expected);
+	 pr "      fprintf (stderr, \"%s: extra elements returned from command\\n\");\n"
+	   test_name;
+	 pr "      print_strings (r);\n";
+	 pr "      return -1;\n";
+	 pr "    }\n"
+       in
+       List.iter (generate_test_command_call test_name) seq;
+       generate_test_command_call ~test test_name last
+   | TestOutputInt (seq, expected) ->
+       pr "  /* TestOutputInt for %s (%d) */\n" name i;
+       let seq, last = get_seq_last seq in
+       let test () =
+	 pr "    if (r != %d) {\n" expected;
+	 pr "      fprintf (stderr, \"%s: expected %d but got %%d\\n\","
+	   test_name expected;
+	 pr "               (int) r);\n";
+	 pr "      return -1;\n";
+	 pr "    }\n"
+       in
+       List.iter (generate_test_command_call test_name) seq;
+       generate_test_command_call ~test test_name last
+   | TestOutputTrue seq ->
+       pr "  /* TestOutputTrue for %s (%d) */\n" name i;
+       let seq, last = get_seq_last seq in
+       let test () =
+	 pr "    if (!r) {\n";
+	 pr "      fprintf (stderr, \"%s: expected true, got false\\n\");\n"
+	   test_name;
+	 pr "      return -1;\n";
+	 pr "    }\n"
+       in
+       List.iter (generate_test_command_call test_name) seq;
+       generate_test_command_call ~test test_name last
+   | TestOutputFalse seq ->
+       pr "  /* TestOutputFalse for %s (%d) */\n" name i;
+       let seq, last = get_seq_last seq in
+       let test () =
+	 pr "    if (r) {\n";
+	 pr "      fprintf (stderr, \"%s: expected false, got true\\n\");\n"
+	   test_name;
+	 pr "      return -1;\n";
+	 pr "    }\n"
+       in
+       List.iter (generate_test_command_call test_name) seq;
+       generate_test_command_call ~test test_name last
+   | TestOutputLength (seq, expected) ->
+       pr "  /* TestOutputLength for %s (%d) */\n" name i;
+       let seq, last = get_seq_last seq in
+       let test () =
+	 pr "    int j;\n";
+	 pr "    for (j = 0; j < %d; ++j)\n" expected;
+	 pr "      if (r[j] == NULL) {\n";
+	 pr "        fprintf (stderr, \"%s: short list returned\\n\");\n"
+	   test_name;
+	 pr "        print_strings (r);\n";
+	 pr "        return -1;\n";
+	 pr "      }\n";
+	 pr "    if (r[j] != NULL) {\n";
+	 pr "      fprintf (stderr, \"%s: long list returned\\n\");\n"
+	   test_name;
+	 pr "      print_strings (r);\n";
+	 pr "      return -1;\n";
+	 pr "    }\n"
+       in
+       List.iter (generate_test_command_call test_name) seq;
+       generate_test_command_call ~test test_name last
+   | TestOutputStruct (seq, checks) ->
+       pr "  /* TestOutputStruct for %s (%d) */\n" name i;
+       let seq, last = get_seq_last seq in
+       let test () =
+	 List.iter (
+	   function
+	   | CompareWithInt (field, expected) ->
+	       pr "    if (r->%s != %d) {\n" field expected;
+	       pr "      fprintf (stderr, \"%s: %s was %%d, expected %d\\n\",\n"
+		 test_name field expected;
+	       pr "               (int) r->%s);\n" field;
+	       pr "      return -1;\n";
+	       pr "    }\n"
+	   | CompareWithString (field, expected) ->
+	       pr "    if (strcmp (r->%s, \"%s\") != 0) {\n" field expected;
+	       pr "      fprintf (stderr, \"%s: %s was \"%%s\", expected \"%s\"\\n\",\n"
+		 test_name field expected;
+	       pr "               r->%s);\n" field;
+	       pr "      return -1;\n";
+	       pr "    }\n"
+	   | CompareFieldsIntEq (field1, field2) ->
+	       pr "    if (r->%s != r->%s) {\n" field1 field2;
+	       pr "      fprintf (stderr, \"%s: %s (%%d) <> %s (%%d)\\n\",\n"
+		 test_name field1 field2;
+	       pr "               (int) r->%s, (int) r->%s);\n" field1 field2;
+	       pr "      return -1;\n";
+	       pr "    }\n"
+	   | CompareFieldsStrEq (field1, field2) ->
+	       pr "    if (strcmp (r->%s, r->%s) != 0) {\n" field1 field2;
+	       pr "      fprintf (stderr, \"%s: %s (\"%%s\") <> %s (\"%%s\")\\n\",\n"
+		 test_name field1 field2;
+	       pr "               r->%s, r->%s);\n" field1 field2;
+	       pr "      return -1;\n";
+	       pr "    }\n"
+	 ) checks
+       in
+       List.iter (generate_test_command_call test_name) seq;
+       generate_test_command_call ~test test_name last
+   | TestLastFail seq ->
+       pr "  /* TestLastFail for %s (%d) */\n" name i;
+       let seq, last = get_seq_last seq in
+       List.iter (generate_test_command_call test_name) seq;
+       generate_test_command_call test_name ~expect_error:true last
+  );
+
+  pr "  return 0;\n";
+  pr "}\n";
+  pr "\n";
+  test_name
+
+(* Generate the code to run a command, leaving the result in 'r'.
+ * If you expect to get an error then you should set expect_error:true.
+ *)
+and generate_test_command_call ?(expect_error = false) ?test test_name cmd =
+  match cmd with
+  | [] -> assert false
+  | name :: args ->
+      (* Look up the command to find out what args/ret it has. *)
+      let style =
+	try
+	  let _, style, _, _, _, _, _ =
+	    List.find (fun (n, _, _, _, _, _, _) -> n = name) all_functions in
+	  style
+	with Not_found ->
+	  failwithf "%s: in test, command %s was not found" test_name name in
+
+      if List.length (snd style) <> List.length args then
+	failwithf "%s: in test, wrong number of args given to %s"
+	  test_name name;
+
+      pr "  {\n";
+
+      List.iter (
+	function
+	| String _, _
+	| OptString _, _
+	| Int _, _
+	| Bool _, _ -> ()
+	| FileIn _, _ | FileOut _, _ -> ()
+	| StringList n, arg ->
+	    pr "    char *%s[] = {\n" n;
+	    let strs = string_split " " arg in
+	    List.iter (
+	      fun str -> pr "      \"%s\",\n" (c_quote str)
+	    ) strs;
+	    pr "      NULL\n";
+	    pr "    };\n";
+      ) (List.combine (snd style) args);
+
+      let error_code =
+	match fst style with
+	| RErr | RInt _ | RBool _ -> pr "    int r;\n"; "-1"
+	| RInt64 _ -> pr "    int64_t r;\n"; "-1"
+	| RConstString _ -> pr "    const char *r;\n"; "NULL"
+	| RString _ -> pr "    char *r;\n"; "NULL"
+	| RStringList _ | RHashtable _ ->
+	    pr "    char **r;\n";
+	    pr "    int i;\n";
+	    "NULL"
+	| RIntBool _ ->
+	    pr "    struct guestfs_int_bool *r;\n"; "NULL"
+	| RPVList _ ->
+	    pr "    struct guestfs_lvm_pv_list *r;\n"; "NULL"
+	| RVGList _ ->
+	    pr "    struct guestfs_lvm_vg_list *r;\n"; "NULL"
+	| RLVList _ ->
+	    pr "    struct guestfs_lvm_lv_list *r;\n"; "NULL"
+	| RStat _ ->
+	    pr "    struct guestfs_stat *r;\n"; "NULL"
+	| RStatVFS _ ->
+	    pr "    struct guestfs_statvfs *r;\n"; "NULL" in
+
+      pr "    suppress_error = %d;\n" (if expect_error then 1 else 0);
+      pr "    r = guestfs_%s (g" name;
+
+      (* Generate the parameters. *)
+      List.iter (
+	function
+	| String _, arg
+	| FileIn _, arg | FileOut _, arg ->
+	    pr ", \"%s\"" (c_quote arg)
+	| OptString _, arg ->
+	    if arg = "NULL" then pr ", NULL" else pr ", \"%s\"" (c_quote arg)
+	| StringList n, _ ->
+	    pr ", %s" n
+	| Int _, arg ->
+	    let i =
+	      try int_of_string arg
+	      with Failure "int_of_string" ->
+		failwithf "%s: expecting an int, but got '%s'" test_name arg in
+	    pr ", %d" i
+	| Bool _, arg ->
+	    let b = bool_of_string arg in pr ", %d" (if b then 1 else 0)
+      ) (List.combine (snd style) args);
+
+      pr ");\n";
+      if not expect_error then
+	pr "    if (r == %s)\n" error_code
+      else
+	pr "    if (r != %s)\n" error_code;
+      pr "      return -1;\n";
+
+      (* Insert the test code. *)
+      (match test with
+       | None -> ()
+       | Some f -> f ()
+      );
+
+      (match fst style with
+       | RErr | RInt _ | RInt64 _ | RBool _ | RConstString _ -> ()
+       | RString _ -> pr "    free (r);\n"
+       | RStringList _ | RHashtable _ ->
+	   pr "    for (i = 0; r[i] != NULL; ++i)\n";
+	   pr "      free (r[i]);\n";
+	   pr "    free (r);\n"
+       | RIntBool _ ->
+	   pr "    guestfs_free_int_bool (r);\n"
+       | RPVList _ ->
+	   pr "    guestfs_free_lvm_pv_list (r);\n"
+       | RVGList _ ->
+	   pr "    guestfs_free_lvm_vg_list (r);\n"
+       | RLVList _ ->
+	   pr "    guestfs_free_lvm_lv_list (r);\n"
+       | RStat _ | RStatVFS _ ->
+	   pr "    free (r);\n"
+      );
+
+      pr "  }\n"
+
+and c_quote str =
+  let str = replace_str str "\r" "\\r" in
+  let str = replace_str str "\n" "\\n" in
+  let str = replace_str str "\t" "\\t" in
+  str
+
 (* Generate a lot of different functions for guestfish. *)
 and generate_fish_cmds () =
   generate_header CStyle GPLv2;
@@ -1893,11 +3627,19 @@ and generate_fish_cmds () =
 
       let warnings =
 	if List.mem ProtocolLimitWarning flags then
-	  "\n\nBecause of the message protocol, there is a transfer limit 
-of somewhere between 2MB and 4MB.  To transfer large files you should use
-FTP."
+	  ("\n\n" ^ protocol_limit_warning)
 	else "" in
 
+      (* For DangerWillRobinson commands, we should probably have
+       * guestfish prompt before allowing you to use them (especially
+       * in interactive mode). XXX
+       *)
+      let warnings =
+	warnings ^
+	  if List.mem DangerWillRobinson flags then
+	    ("\n\n" ^ danger_will_robinson)
+	  else "" in
+
       let describe_alias =
 	if name <> alias then
 	  sprintf "\n\nYou can use '%s' as an alias for this command." alias
@@ -1958,6 +3700,21 @@ FTP."
 	pr "\n";
   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
 
+  (* print_{stat,statvfs} functions *)
+  List.iter (
+    function
+    | typ, cols ->
+	pr "static void print_%s (struct guestfs_%s *%s)\n" typ typ typ;
+	pr "{\n";
+	List.iter (
+	  function
+	  | name, `Int ->
+	      pr "  printf (\"%s: %%\" PRIi64 \"\\n\", %s->%s);\n" name typ name
+	) cols;
+	pr "}\n";
+	pr "\n";
+  ) ["stat", stat_cols; "statvfs", statvfs_cols];
+
   (* run_<action> actions *)
   List.iter (
     fun (name, style, _, flags, _, _, _) ->
@@ -1967,18 +3724,24 @@ FTP."
        | RErr
        | RInt _
        | RBool _ -> pr "  int r;\n"
+       | RInt64 _ -> pr "  int64_t r;\n"
        | RConstString _ -> pr "  const char *r;\n"
        | RString _ -> pr "  char *r;\n"
-       | RStringList _ -> pr "  char **r;\n"
+       | RStringList _ | RHashtable _ -> pr "  char **r;\n"
        | RIntBool _ -> pr "  struct guestfs_int_bool *r;\n"
        | RPVList _ -> pr "  struct guestfs_lvm_pv_list *r;\n"
        | RVGList _ -> pr "  struct guestfs_lvm_vg_list *r;\n"
        | RLVList _ -> pr "  struct guestfs_lvm_lv_list *r;\n"
+       | RStat _ -> pr "  struct guestfs_stat *r;\n"
+       | RStatVFS _ -> pr "  struct guestfs_statvfs *r;\n"
       );
       List.iter (
 	function
-	| String n -> pr "  const char *%s;\n" n
-	| OptString n -> pr "  const char *%s;\n" n
+	| String n
+	| OptString n
+	| FileIn n
+	| FileOut n -> pr "  const char *%s;\n" n
+	| StringList n -> pr "  char **%s;\n" n
 	| Bool n -> pr "  int %s;\n" n
 	| Int n -> pr "  int %s;\n" n
       ) (snd style);
@@ -1998,6 +3761,14 @@ FTP."
 	  | OptString name ->
 	      pr "  %s = strcmp (argv[%d], \"\") != 0 ? argv[%d] : NULL;\n"
 		name i i
+	  | FileIn name ->
+	      pr "  %s = strcmp (argv[%d], \"-\") != 0 ? argv[%d] : \"/dev/stdin\";\n"
+		name i i
+	  | FileOut name ->
+	      pr "  %s = strcmp (argv[%d], \"-\") != 0 ? argv[%d] : \"/dev/stdout\";\n"
+		name i i
+	  | StringList name ->
+	      pr "  %s = parse_string_list (argv[%d]);\n" name i
 	  | Bool name ->
 	      pr "  %s = is_true (argv[%d]) ? 1 : 0;\n" name i
 	  | Int name ->
@@ -2009,7 +3780,7 @@ FTP."
 	try find_map (function FishAction n -> Some n | _ -> None) flags
 	with Not_found -> sprintf "guestfs_%s" name in
       pr "  r = %s " fn;
-      generate_call_args ~handle:"g" style;
+      generate_call_args ~handle:"g" (snd style);
       pr ";\n";
 
       (* Check return value for errors and display command results. *)
@@ -2017,7 +3788,11 @@ FTP."
        | RErr -> pr "  return r;\n"
        | RInt _ ->
 	   pr "  if (r == -1) return -1;\n";
-	   pr "  if (r) printf (\"%%d\\n\", r);\n";
+	   pr "  printf (\"%%d\\n\", r);\n";
+	   pr "  return 0;\n"
+       | RInt64 _ ->
+	   pr "  if (r == -1) return -1;\n";
+	   pr "  printf (\"%%\" PRIi64 \"\\n\", r);\n";
 	   pr "  return 0;\n"
        | RBool _ ->
 	   pr "  if (r == -1) return -1;\n";
@@ -2058,6 +3833,21 @@ FTP."
 	   pr "  print_lv_list (r);\n";
 	   pr "  guestfs_free_lvm_lv_list (r);\n";
 	   pr "  return 0;\n"
+       | RStat _ ->
+	   pr "  if (r == NULL) return -1;\n";
+	   pr "  print_stat (r);\n";
+	   pr "  free (r);\n";
+	   pr "  return 0;\n"
+       | RStatVFS _ ->
+	   pr "  if (r == NULL) return -1;\n";
+	   pr "  print_statvfs (r);\n";
+	   pr "  free (r);\n";
+	   pr "  return 0;\n"
+       | RHashtable _ ->
+	   pr "  if (r == NULL) return -1;\n";
+	   pr "  print_table (r);\n";
+	   pr "  free_strings (r);\n";
+	   pr "  return 0;\n"
       );
       pr "}\n";
       pr "\n"
@@ -2090,24 +3880,115 @@ FTP."
   pr "}\n";
   pr "\n"
 
-(* Generate the POD documentation for guestfish. *)
-and generate_fish_actions_pod () =
-  let all_functions_sorted =
+(* Readline completion for guestfish. *)
+and generate_fish_completion () =
+  generate_header CStyle GPLv2;
+
+  let all_functions =
     List.filter (
       fun (_, _, _, flags, _, _, _) -> not (List.mem NotInFish flags)
-    ) all_functions_sorted in
+    ) all_functions in
 
-  List.iter (
-    fun (name, style, _, flags, _, _, longdesc) ->
-      let longdesc = replace_str longdesc "C<guestfs_" "C<" in
-      let name = replace_char name '_' '-' in
-      let alias =
-	try find_map (function FishAlias n -> Some n | _ -> None) flags
-	with Not_found -> name in
+  pr "\
+#include <config.h>
 
-      pr "=head2 %s" name;
-      if name <> alias then
-	pr " | %s" alias;
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_LIBREADLINE
+#include <readline/readline.h>
+#endif
+
+#include \"fish.h\"
+
+#ifdef HAVE_LIBREADLINE
+
+static const char *const commands[] = {
+";
+
+  (* Get the commands and sort them, including the aliases. *)
+  let commands =
+    List.map (
+      fun (name, _, _, flags, _, _, _) ->
+	let name2 = replace_char name '_' '-' in
+	let alias =
+	  try find_map (function FishAlias n -> Some n | _ -> None) flags
+	  with Not_found -> name in
+
+	if name <> alias then [name2; alias] else [name2]
+    ) all_functions in
+  let commands = List.flatten commands in
+  let commands = List.sort compare commands in
+
+  List.iter (pr "  \"%s\",\n") commands;
+
+  pr "  NULL
+};
+
+static char *
+generator (const char *text, int state)
+{
+  static int index, len;
+  const char *name;
+
+  if (!state) {
+    index = 0;
+    len = strlen (text);
+  }
+
+  while ((name = commands[index]) != NULL) {
+    index++;
+    if (strncasecmp (name, text, len) == 0)
+      return strdup (name);
+  }
+
+  return NULL;
+}
+
+#endif /* HAVE_LIBREADLINE */
+
+char **do_completion (const char *text, int start, int end)
+{
+  char **matches = NULL;
+
+#ifdef HAVE_LIBREADLINE
+  if (start == 0)
+    matches = rl_completion_matches (text, generator);
+#endif
+
+  return matches;
+}
+";
+
+(* Generate the POD documentation for guestfish. *)
+and generate_fish_actions_pod () =
+  let all_functions_sorted =
+    List.filter (
+      fun (_, _, _, flags, _, _, _) -> not (List.mem NotInFish flags)
+    ) all_functions_sorted in
+
+  let rex = Str.regexp "C<guestfs_\\([^>]+\\)>" in
+
+  List.iter (
+    fun (name, style, _, flags, _, _, longdesc) ->
+      let longdesc =
+	Str.global_substitute rex (
+	  fun s ->
+	    let sub =
+	      try Str.matched_group 1 s
+	      with Not_found ->
+		failwithf "error substituting C<guestfs_...> in longdesc of function %s" name in
+	    "C<" ^ replace_char sub '_' '-' ^ ">"
+	) longdesc in
+      let name = replace_char name '_' '-' in
+      let alias =
+	try find_map (function FishAlias n -> Some n | _ -> None) flags
+	with Not_found -> name in
+
+      pr "=head2 %s" name;
+      if name <> alias then
+	pr " | %s" alias;
       pr "\n";
       pr "\n";
       pr " %s" name;
@@ -2115,12 +3996,24 @@ and generate_fish_actions_pod () =
 	function
 	| String n -> pr " %s" n
 	| OptString n -> pr " %s" n
+	| StringList n -> pr " '%s ...'" n
 	| Bool _ -> pr " true|false"
 	| Int n -> pr " %s" n
+	| FileIn n | FileOut n -> pr " (%s|-)" n
       ) (snd style);
       pr "\n";
       pr "\n";
-      pr "%s\n\n" longdesc
+      pr "%s\n\n" longdesc;
+
+      if List.exists (function FileIn _ | FileOut _ -> true
+		      | _ -> false) (snd style) then
+	pr "Use C<-> instead of a filename to read/write from stdin/stdout.\n\n";
+
+      if List.mem ProtocolLimitWarning flags then
+	pr "%s\n\n" protocol_limit_warning;
+
+      if List.mem DangerWillRobinson flags then
+	pr "%s\n\n" danger_will_robinson
   ) all_functions_sorted
 
 (* Generate a C function prototype. *)
@@ -2133,10 +4026,11 @@ and generate_prototype ?(extern = true) ?(static = false) ?(semicolon = true)
   (match fst style with
    | RErr -> pr "int "
    | RInt _ -> pr "int "
+   | RInt64 _ -> pr "int64_t "
    | RBool _ -> pr "int "
    | RConstString _ -> pr "const char *"
    | RString _ -> pr "char *"
-   | RStringList _ -> pr "char **"
+   | RStringList _ | RHashtable _ -> pr "char **"
    | RIntBool _ ->
        if not in_daemon then pr "struct guestfs_int_bool *"
        else pr "guestfs_%s_ret *" name
@@ -2149,6 +4043,12 @@ and generate_prototype ?(extern = true) ?(static = false) ?(semicolon = true)
    | RLVList _ ->
        if not in_daemon then pr "struct guestfs_lvm_lv_list *"
        else pr "guestfs_lvm_int_lv_list *"
+   | RStat _ ->
+       if not in_daemon then pr "struct guestfs_stat *"
+       else pr "guestfs_int_stat *"
+   | RStatVFS _ ->
+       if not in_daemon then pr "struct guestfs_statvfs *"
+       else pr "guestfs_int_statvfs *"
   );
   pr "%s%s (" prefix name;
   if handle = None && List.length (snd style) = 0 then
@@ -2167,10 +4067,14 @@ and generate_prototype ?(extern = true) ?(static = false) ?(semicolon = true)
     in
     List.iter (
       function
-      | String n -> next (); pr "const char *%s" n
+      | String n
       | OptString n -> next (); pr "const char *%s" n
+      | StringList n -> next (); pr "char * const* const %s" n
       | Bool n -> next (); pr "int %s" n
       | Int n -> next (); pr "int %s" n
+      | FileIn n
+      | FileOut n ->
+	  if not in_daemon then (next (); pr "const char *%s" n)
     ) (snd style);
   );
   pr ")";
@@ -2178,7 +4082,7 @@ and generate_prototype ?(extern = true) ?(static = false) ?(semicolon = true)
   if newline then pr "\n"
 
 (* Generate C call arguments, eg "(handle, foo, bar)" *)
-and generate_call_args ?handle style =
+and generate_call_args ?handle args =
   pr "(";
   let comma = ref false in
   (match handle with
@@ -2189,12 +4093,8 @@ and generate_call_args ?handle style =
     fun arg ->
       if !comma then pr ", ";
       comma := true;
-      match arg with
-      | String n -> pr "%s" n
-      | OptString n -> pr "%s" n
-      | Bool n -> pr "%s" n
-      | Int n -> pr "%s" n
-  ) (snd style);
+      pr "%s" (name_of_argt arg)
+  ) args;
   pr ")"
 
 (* Generate the OCaml bindings interface. *)
@@ -2222,6 +4122,8 @@ val close : t -> unit
 ";
   generate_ocaml_lvm_structure_decls ();
 
+  generate_ocaml_stat_structure_decls ();
+
   (* The actions. *)
   List.iter (
     fun (name, style, _, _, _, shortdesc, _) ->
@@ -2247,6 +4149,8 @@ let () =
 
   generate_ocaml_lvm_structure_decls ();
 
+  generate_ocaml_stat_structure_decls ();
+
   (* The actions. *)
   List.iter (
     fun (name, style, _, _, _, shortdesc, _) ->
@@ -2257,22 +4161,51 @@ let () =
 and generate_ocaml_c () =
   generate_header CStyle LGPLv2;
 
-  pr "#include <stdio.h>\n";
-  pr "#include <stdlib.h>\n";
-  pr "#include <string.h>\n";
-  pr "\n";
-  pr "#include <caml/config.h>\n";
-  pr "#include <caml/alloc.h>\n";
-  pr "#include <caml/callback.h>\n";
-  pr "#include <caml/fail.h>\n";
-  pr "#include <caml/memory.h>\n";
-  pr "#include <caml/mlvalues.h>\n";
-  pr "#include <caml/signals.h>\n";
-  pr "\n";
-  pr "#include <guestfs.h>\n";
-  pr "\n";
-  pr "#include \"guestfs_c.h\"\n";
-  pr "\n";
+  pr "\
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <caml/config.h>
+#include <caml/alloc.h>
+#include <caml/callback.h>
+#include <caml/fail.h>
+#include <caml/memory.h>
+#include <caml/mlvalues.h>
+#include <caml/signals.h>
+
+#include <guestfs.h>
+
+#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);
+}
+
+";
 
   (* LVM struct copy functions. *)
   List.iter (
@@ -2337,20 +4270,51 @@ and generate_ocaml_c () =
       pr "\n";
   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
 
+  (* Stat copy functions. *)
+  List.iter (
+    fun (typ, cols) ->
+      pr "static CAMLprim value\n";
+      pr "copy_%s (const struct guestfs_%s *%s)\n" typ typ typ;
+      pr "{\n";
+      pr "  CAMLparam0 ();\n";
+      pr "  CAMLlocal2 (rv, v);\n";
+      pr "\n";
+      pr "  rv = caml_alloc (%d, 0);\n" (List.length cols);
+      iteri (
+	fun i col ->
+	  (match col with
+	   | name, `Int ->
+	       pr "  v = caml_copy_int64 (%s->%s);\n" typ name
+	  );
+	  pr "  Store_field (rv, %d, v);\n" i
+      ) cols;
+      pr "  CAMLreturn (rv);\n";
+      pr "}\n";
+      pr "\n";
+  ) ["stat", stat_cols; "statvfs", statvfs_cols];
+
+  (* The wrappers. *)
   List.iter (
     fun (name, style, _, _, _, _, _) ->
+      let params =
+	"gv" :: List.map (fun arg -> name_of_argt arg ^ "v") (snd style) in
+
       pr "CAMLprim value\n";
-      pr "ocaml_guestfs_%s (value gv" name;
-      List.iter (
-	fun arg -> pr ", value %sv" (name_of_argt arg)
-      ) (snd style);
+      pr "ocaml_guestfs_%s (value %s" name (List.hd params);
+      List.iter (pr ", value %s") (List.tl params);
       pr ")\n";
       pr "{\n";
-      pr "  CAMLparam%d (gv" (1 + (List.length (snd style)));
-      List.iter (
-	fun arg -> pr ", %sv" (name_of_argt arg)
-      ) (snd style);
-      pr ");\n";
+
+      (match params with
+       | [p1; p2; p3; p4; p5] ->
+	   pr "  CAMLparam5 (%s);\n" (String.concat ", " params)
+       | p1 :: p2 :: p3 :: p4 :: p5 :: rest ->
+	   pr "  CAMLparam5 (%s);\n" (String.concat ", " [p1; p2; p3; p4; p5]);
+	   pr "  CAMLxparam%d (%s);\n"
+	     (List.length rest) (String.concat ", " rest)
+       | ps ->
+	   pr "  CAMLparam%d (%s);\n" (List.length ps) (String.concat ", " ps)
+      );
       pr "  CAMLlocal1 (rv);\n";
       pr "\n";
 
@@ -2361,12 +4325,16 @@ and generate_ocaml_c () =
 
       List.iter (
 	function
-	| String n ->
+	| String n
+	| FileIn n
+	| FileOut n ->
 	    pr "  const char *%s = String_val (%sv);\n" n n
 	| OptString n ->
 	    pr "  const char *%s =\n" n;
 	    pr "    %sv != Val_int (0) ? String_val (Field (%sv, 0)) : NULL;\n"
 	      n n
+	| StringList n ->
+	    pr "  char **%s = ocaml_guestfs_strings_val (g, %sv);\n" n n
 	| Bool n ->
 	    pr "  int %s = Bool_val (%sv);\n" n n
 	| Int n ->
@@ -2376,6 +4344,7 @@ and generate_ocaml_c () =
 	match fst style with
 	| RErr -> pr "  int r;\n"; "-1"
 	| RInt _ -> pr "  int r;\n"; "-1"
+	| RInt64 _ -> pr "  int64_t r;\n"; "-1"
 	| RBool _ -> pr "  int r;\n"; "-1"
 	| RConstString _ -> pr "  const char *r;\n"; "NULL"
 	| RString _ -> pr "  char *r;\n"; "NULL"
@@ -2384,24 +4353,36 @@ and generate_ocaml_c () =
 	    pr "  char **r;\n";
 	    "NULL"
 	| RIntBool _ ->
-	    pr "  struct guestfs_int_bool *r;\n";
-	    "NULL"
+	    pr "  struct guestfs_int_bool *r;\n"; "NULL"
 	| RPVList _ ->
-	    pr "  struct guestfs_lvm_pv_list *r;\n";
-	    "NULL"
+	    pr "  struct guestfs_lvm_pv_list *r;\n"; "NULL"
 	| RVGList _ ->
-	    pr "  struct guestfs_lvm_vg_list *r;\n";
-	    "NULL"
+	    pr "  struct guestfs_lvm_vg_list *r;\n"; "NULL"
 	| RLVList _ ->
-	    pr "  struct guestfs_lvm_lv_list *r;\n";
+	    pr "  struct guestfs_lvm_lv_list *r;\n"; "NULL"
+	| RStat _ ->
+	    pr "  struct guestfs_stat *r;\n"; "NULL"
+	| RStatVFS _ ->
+	    pr "  struct guestfs_statvfs *r;\n"; "NULL"
+	| RHashtable _ ->
+	    pr "  int i;\n";
+	    pr "  char **r;\n";
 	    "NULL" in
       pr "\n";
 
       pr "  caml_enter_blocking_section ();\n";
       pr "  r = guestfs_%s " name;
-      generate_call_args ~handle:"g" style;
+      generate_call_args ~handle:"g" (snd style);
       pr ";\n";
       pr "  caml_leave_blocking_section ();\n";
+
+      List.iter (
+	function
+	| StringList n ->
+	    pr "  ocaml_guestfs_free_strings (%s);\n" n;
+	| String _ | OptString _ | Bool _ | Int _ | FileIn _ | FileOut _ -> ()
+      ) (snd style);
+
       pr "  if (r == %s)\n" error_code;
       pr "    ocaml_guestfs_raise_error (g, \"%s\");\n" name;
       pr "\n";
@@ -2409,6 +4390,8 @@ and generate_ocaml_c () =
       (match fst style with
        | RErr -> pr "  rv = Val_unit;\n"
        | RInt _ -> pr "  rv = Val_int (r);\n"
+       | RInt64 _ ->
+	   pr "  rv = caml_copy_int64 (r);\n"
        | RBool _ -> pr "  rv = Val_bool (r);\n"
        | RConstString _ -> pr "  rv = caml_copy_string (r);\n"
        | RString _ ->
@@ -2432,11 +4415,32 @@ and generate_ocaml_c () =
        | RLVList _ ->
 	   pr "  rv = copy_lvm_lv_list (r);\n";
 	   pr "  guestfs_free_lvm_lv_list (r);\n";
+       | RStat _ ->
+	   pr "  rv = copy_stat (r);\n";
+	   pr "  free (r);\n";
+       | RStatVFS _ ->
+	   pr "  rv = copy_statvfs (r);\n";
+	   pr "  free (r);\n";
+       | RHashtable _ ->
+	   pr "  rv = copy_table (r);\n";
+	   pr "  for (i = 0; r[i] != NULL; ++i) free (r[i]);\n";
+	   pr "  free (r);\n";
       );
 
       pr "  CAMLreturn (rv);\n";
       pr "}\n";
-      pr "\n"
+      pr "\n";
+
+      if List.length params > 5 then (
+	pr "CAMLprim value\n";
+	pr "ocaml_guestfs_%s_byte (value *argv, int argn)\n" name;
+	pr "{\n";
+	pr "  return ocaml_guestfs_%s (argv[0]" name;
+	iteri (fun i _ -> pr ", argv[%d]" i) (List.tl params);
+	pr ");\n";
+	pr "}\n";
+	pr "\n"
+      )
   ) all_functions
 
 and generate_ocaml_lvm_structure_decls () =
@@ -2455,19 +4459,33 @@ and generate_ocaml_lvm_structure_decls () =
       pr "\n"
   ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols]
 
+and generate_ocaml_stat_structure_decls () =
+  List.iter (
+    fun (typ, cols) ->
+      pr "type %s = {\n" typ;
+      List.iter (
+	function
+	| name, `Int -> pr "  %s : int64;\n" name
+      ) cols;
+      pr "}\n";
+      pr "\n"
+  ) ["stat", stat_cols; "statvfs", statvfs_cols]
+
 and generate_ocaml_prototype ?(is_external = false) name style =
   if is_external then pr "external " else pr "val ";
   pr "%s : t -> " name;
   List.iter (
     function
-    | String _ -> pr "string -> "
+    | String _ | FileIn _ | FileOut _ -> pr "string -> "
     | OptString _ -> pr "string option -> "
+    | StringList _ -> pr "string array -> "
     | Bool _ -> pr "bool -> "
     | Int _ -> pr "int -> "
   ) (snd style);
   (match fst style with
    | RErr -> pr "unit" (* all errors are turned into exceptions *)
    | RInt _ -> pr "int"
+   | RInt64 _ -> pr "int64"
    | RBool _ -> pr "bool"
    | RConstString _ -> pr "string"
    | RString _ -> pr "string"
@@ -2476,8 +4494,16 @@ and generate_ocaml_prototype ?(is_external = false) name style =
    | RPVList _ -> pr "lvm_pv array"
    | RVGList _ -> pr "lvm_vg array"
    | RLVList _ -> pr "lvm_lv array"
+   | RStat _ -> pr "stat"
+   | RStatVFS _ -> pr "statvfs"
+   | RHashtable _ -> pr "(string * string) list"
+  );
+  if is_external then (
+    pr " = ";
+    if List.length (snd style) + 1 > 5 then
+      pr "\"ocaml_guestfs_%s_byte\" " name;
+    pr "\"ocaml_guestfs_%s\"" name
   );
-  if is_external then pr " = \"ocaml_guestfs_%s\"" name;
   pr "\n"
 
 (* Generate Perl xs code, a sort of crazy variation of C with macros. *)
@@ -2523,20 +4549,33 @@ my_newSVull(unsigned long long val) {
 #endif
 }
 
-/* XXX Not thread-safe, and in general not safe if the caller is
- * issuing multiple requests in parallel (on different guestfs
- * handles).  We should use the guestfs_h handle passed to the
- * error handle to distinguish these cases.
- */
-static char *last_error = NULL;
+/* http://www.perlmonks.org/?node_id=680842 */
+static char **
+XS_unpack_charPtrPtr (SV *arg) {
+  char **ret;
+  AV *av;
+  I32 i;
 
-static void
-error_handler (guestfs_h *g,
-	       void *data,
-	       const char *msg)
-{
-  if (last_error != NULL) free (last_error);
-  last_error = strdup (msg);
+  if (!arg || !SvOK (arg) || !SvROK (arg) || SvTYPE (SvRV (arg)) != SVt_PVAV)
+    croak (\"array reference expected\");
+
+  av = (AV *)SvRV (arg);
+  ret = malloc (av_len (av) + 1 + 1);
+  if (!ret)
+    croak (\"malloc failed\");
+
+  for (i = 0; i <= av_len (av); i++) {
+    SV **elem = av_fetch (av, i, 0);
+
+    if (!elem || !*elem)
+      croak (\"missing element in list\");
+
+    ret[i] = SvPV_nolen (*elem);
+  }
+
+  ret[i] = NULL;
+
+  return ret;
 }
 
 MODULE = Sys::Guestfs  PACKAGE = Sys::Guestfs
@@ -2547,7 +4586,7 @@ _create ()
       RETVAL = guestfs_create ();
       if (!RETVAL)
         croak (\"could not create guestfs handle\");
-      guestfs_set_error_handler (RETVAL, error_handler, NULL);
+      guestfs_set_error_handler (RETVAL, NULL, NULL);
  OUTPUT:
       RETVAL
 
@@ -2564,56 +4603,89 @@ DESTROY (g)
       (match fst style with
        | RErr -> pr "void\n"
        | RInt _ -> pr "SV *\n"
+       | RInt64 _ -> pr "SV *\n"
        | RBool _ -> pr "SV *\n"
        | RConstString _ -> pr "SV *\n"
        | RString _ -> pr "SV *\n"
        | RStringList _
        | RIntBool _
-       | RPVList _ | RVGList _ | RLVList _ ->
+       | RPVList _ | RVGList _ | RLVList _
+       | RStat _ | RStatVFS _
+       | RHashtable _ ->
 	   pr "void\n" (* all lists returned implictly on the stack *)
       );
       (* Call and arguments. *)
       pr "%s " name;
-      generate_call_args ~handle:"g" style;
+      generate_call_args ~handle:"g" (snd style);
       pr "\n";
       pr "      guestfs_h *g;\n";
       List.iter (
 	function
-	| String n -> pr "      char *%s;\n" n
+	| String n | FileIn n | FileOut n -> pr "      char *%s;\n" n
 	| OptString n -> pr "      char *%s;\n" n
+	| StringList n -> pr "      char **%s;\n" n
 	| Bool n -> pr "      int %s;\n" n
 	| Int n -> pr "      int %s;\n" n
       ) (snd style);
+
+      let do_cleanups () =
+	List.iter (
+	  function
+	  | String _ | OptString _ | Bool _ | Int _
+	  | FileIn _ | FileOut _ -> ()
+	  | StringList n -> pr "      free (%s);\n" n
+	) (snd style)
+      in
+
       (* Code. *)
       (match fst style with
        | RErr ->
+	   pr "PREINIT:\n";
+	   pr "      int r;\n";
 	   pr " PPCODE:\n";
-	   pr "      if (guestfs_%s " name;
-	   generate_call_args ~handle:"g" style;
-	   pr " == -1)\n";
-	   pr "        croak (\"%s: %%s\", last_error);\n" name
+	   pr "      r = guestfs_%s " name;
+	   generate_call_args ~handle:"g" (snd style);
+	   pr ";\n";
+	   do_cleanups ();
+	   pr "      if (r == -1)\n";
+	   pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
        | RInt n
        | RBool n ->
 	   pr "PREINIT:\n";
 	   pr "      int %s;\n" n;
 	   pr "   CODE:\n";
 	   pr "      %s = guestfs_%s " n name;
-	   generate_call_args ~handle:"g" style;
+	   generate_call_args ~handle:"g" (snd style);
 	   pr ";\n";
+	   do_cleanups ();
 	   pr "      if (%s == -1)\n" n;
-	   pr "        croak (\"%s: %%s\", last_error);\n" name;
+	   pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
 	   pr "      RETVAL = newSViv (%s);\n" n;
 	   pr " OUTPUT:\n";
 	   pr "      RETVAL\n"
+       | RInt64 n ->
+	   pr "PREINIT:\n";
+	   pr "      int64_t %s;\n" n;
+	   pr "   CODE:\n";
+	   pr "      %s = guestfs_%s " n name;
+	   generate_call_args ~handle:"g" (snd style);
+	   pr ";\n";
+	   do_cleanups ();
+	   pr "      if (%s == -1)\n" n;
+	   pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
+	   pr "      RETVAL = my_newSVll (%s);\n" n;
+	   pr " OUTPUT:\n";
+	   pr "      RETVAL\n"
        | RConstString n ->
 	   pr "PREINIT:\n";
 	   pr "      const char *%s;\n" n;
 	   pr "   CODE:\n";
 	   pr "      %s = guestfs_%s " n name;
-	   generate_call_args ~handle:"g" style;
+	   generate_call_args ~handle:"g" (snd style);
 	   pr ";\n";
+	   do_cleanups ();
 	   pr "      if (%s == NULL)\n" n;
-	   pr "        croak (\"%s: %%s\", last_error);\n" name;
+	   pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
 	   pr "      RETVAL = newSVpv (%s, 0);\n" n;
 	   pr " OUTPUT:\n";
 	   pr "      RETVAL\n"
@@ -2622,24 +4694,26 @@ DESTROY (g)
 	   pr "      char *%s;\n" n;
 	   pr "   CODE:\n";
 	   pr "      %s = guestfs_%s " n name;
-	   generate_call_args ~handle:"g" style;
+	   generate_call_args ~handle:"g" (snd style);
 	   pr ";\n";
+	   do_cleanups ();
 	   pr "      if (%s == NULL)\n" n;
-	   pr "        croak (\"%s: %%s\", last_error);\n" name;
+	   pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
 	   pr "      RETVAL = newSVpv (%s, 0);\n" n;
 	   pr "      free (%s);\n" n;
 	   pr " OUTPUT:\n";
 	   pr "      RETVAL\n"
-       | RStringList n ->
+       | RStringList n | RHashtable n ->
 	   pr "PREINIT:\n";
 	   pr "      char **%s;\n" n;
 	   pr "      int i, n;\n";
 	   pr " PPCODE:\n";
 	   pr "      %s = guestfs_%s " n name;
-	   generate_call_args ~handle:"g" style;
+	   generate_call_args ~handle:"g" (snd style);
 	   pr ";\n";
+	   do_cleanups ();
 	   pr "      if (%s == NULL)\n" n;
-	   pr "        croak (\"%s: %%s\", last_error);\n" name;
+	   pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
 	   pr "      for (n = 0; %s[n] != NULL; ++n) /**/;\n" n;
 	   pr "      EXTEND (SP, n);\n";
 	   pr "      for (i = 0; i < n; ++i) {\n";
@@ -2652,35 +4726,43 @@ DESTROY (g)
 	   pr "      struct guestfs_int_bool *r;\n";
 	   pr " PPCODE:\n";
 	   pr "      r = guestfs_%s " name;
-	   generate_call_args ~handle:"g" style;
+	   generate_call_args ~handle:"g" (snd style);
 	   pr ";\n";
+	   do_cleanups ();
 	   pr "      if (r == NULL)\n";
-	   pr "        croak (\"%s: %%s\", last_error);\n" name;
+	   pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
 	   pr "      EXTEND (SP, 2);\n";
 	   pr "      PUSHs (sv_2mortal (newSViv (r->i)));\n";
 	   pr "      PUSHs (sv_2mortal (newSViv (r->b)));\n";
 	   pr "      guestfs_free_int_bool (r);\n";
        | RPVList n ->
-	   generate_perl_lvm_code "pv" pv_cols name style n;
+	   generate_perl_lvm_code "pv" pv_cols name style n do_cleanups
        | RVGList n ->
-	   generate_perl_lvm_code "vg" vg_cols name style n;
+	   generate_perl_lvm_code "vg" vg_cols name style n do_cleanups
        | RLVList n ->
-	   generate_perl_lvm_code "lv" lv_cols name style n;
+	   generate_perl_lvm_code "lv" lv_cols name style n do_cleanups
+       | RStat n ->
+	   generate_perl_stat_code "stat" stat_cols name style n do_cleanups
+       | RStatVFS n ->
+	   generate_perl_stat_code
+	     "statvfs" statvfs_cols name style n do_cleanups
       );
+
       pr "\n"
   ) all_functions
 
-and generate_perl_lvm_code typ cols name style n =
+and generate_perl_lvm_code typ cols name style n do_cleanups =
   pr "PREINIT:\n";
   pr "      struct guestfs_lvm_%s_list *%s;\n" typ n;
   pr "      int i;\n";
   pr "      HV *hv;\n";
   pr " PPCODE:\n";
   pr "      %s = guestfs_%s " n name;
-  generate_call_args ~handle:"g" style;
+  generate_call_args ~handle:"g" (snd style);
   pr ";\n";
+  do_cleanups ();
   pr "      if (%s == NULL)\n" n;
-  pr "        croak (\"%s: %%s\", last_error);\n" name;
+  pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
   pr "      EXTEND (SP, %s->len);\n" n;
   pr "      for (i = 0; i < %s->len; ++i) {\n" n;
   pr "        hv = newHV ();\n";
@@ -2706,6 +4788,24 @@ and generate_perl_lvm_code typ cols name style n =
   pr "      }\n";
   pr "      guestfs_free_lvm_%s_list (%s);\n" typ n
 
+and generate_perl_stat_code typ cols name style n do_cleanups =
+  pr "PREINIT:\n";
+  pr "      struct guestfs_%s *%s;\n" typ n;
+  pr " PPCODE:\n";
+  pr "      %s = guestfs_%s " n name;
+  generate_call_args ~handle:"g" (snd style);
+  pr ";\n";
+  do_cleanups ();
+  pr "      if (%s == NULL)\n" n;
+  pr "        croak (\"%s: %%s\", guestfs_last_error (g));\n" name;
+  pr "      EXTEND (SP, %d);\n" (List.length cols);
+  List.iter (
+    function
+    | name, `Int ->
+	pr "      PUSHs (sv_2mortal (my_newSVll (%s->%s)));\n" n name
+  ) cols;
+  pr "      free (%s);\n" n
+
 (* Generate Sys/Guestfs.pm. *)
 and generate_perl_pm () =
   generate_header HashStyle LGPLv2;
@@ -2797,9 +4897,9 @@ sub new {
       pr "\n\n";
       pr "%s\n\n" longdesc;
       if List.mem ProtocolLimitWarning flags then
-	pr "Because of the message protocol, there is a transfer limit 
-of somewhere between 2MB and 4MB.  To transfer large files you should use
-FTP.\n\n";
+	pr "%s\n\n" protocol_limit_warning;
+      if List.mem DangerWillRobinson flags then
+	pr "%s\n\n" danger_will_robinson
   ) all_functions_sorted;
 
   (* End of file. *)
@@ -2830,6 +4930,7 @@ and generate_perl_prototype name style =
    | RErr -> ()
    | RBool n
    | RInt n
+   | RInt64 n
    | RConstString n
    | RString n -> pr "$%s = " n
    | RIntBool (n, m) -> pr "($%s, $%s) = " n m
@@ -2837,6 +4938,9 @@ and generate_perl_prototype name style =
    | RPVList n
    | RVGList n
    | RLVList n -> pr "@%s = " n
+   | RStat n
+   | RStatVFS n
+   | RHashtable n -> pr "%%%s = " n
   );
   pr "$h->%s (" name;
   let comma = ref false in
@@ -2844,94 +4948,1407 @@ and generate_perl_prototype name style =
     fun arg ->
       if !comma then pr ", ";
       comma := true;
-      pr "%s" (name_of_argt arg)
+      match arg with
+      | String n | OptString n | Bool n | Int n | FileIn n | FileOut n ->
+	  pr "$%s" n
+      | StringList n ->
+	  pr "\\@%s" n
   ) (snd style);
   pr ");"
 
-let output_to filename =
-  let filename_new = filename ^ ".new" in
-  chan := open_out filename_new;
-  let close () =
-    close_out !chan;
-    chan := stdout;
-    Unix.rename filename_new filename;
-    printf "written %s\n%!" filename;
-  in
-  close
+(* Generate Python C module. *)
+and generate_python_c () =
+  generate_header CStyle LGPLv2;
 
-(* Main program. *)
-let () =
-  check_functions ();
+  pr "\
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
 
-  if not (Sys.file_exists "configure.ac") then (
-    eprintf "\
-You are probably running this from the wrong directory.
-Run it from the top source directory using the command
-  src/generator.ml
-";
-    exit 1
-  );
+#include <Python.h>
 
-  let close = output_to "src/guestfs_protocol.x" in
-  generate_xdr ();
-  close ();
+#include \"guestfs.h\"
 
-  let close = output_to "src/guestfs-structs.h" in
-  generate_structs_h ();
-  close ();
+typedef struct {
+  PyObject_HEAD
+  guestfs_h *g;
+} Pyguestfs_Object;
 
-  let close = output_to "src/guestfs-actions.h" in
-  generate_actions_h ();
-  close ();
+static guestfs_h *
+get_handle (PyObject *obj)
+{
+  assert (obj);
+  assert (obj != Py_None);
+  return ((Pyguestfs_Object *) obj)->g;
+}
 
-  let close = output_to "src/guestfs-actions.c" in
-  generate_client_actions ();
-  close ();
+static PyObject *
+put_handle (guestfs_h *g)
+{
+  assert (g);
+  return
+    PyCObject_FromVoidPtrAndDesc ((void *) g, (char *) \"guestfs_h\", NULL);
+}
 
-  let close = output_to "daemon/actions.h" in
-  generate_daemon_actions_h ();
-  close ();
+/* This list should be freed (but not the strings) after use. */
+static const char **
+get_string_list (PyObject *obj)
+{
+  int i, len;
+  const char **r;
 
-  let close = output_to "daemon/stubs.c" in
-  generate_daemon_actions ();
-  close ();
+  assert (obj);
 
-  let close = output_to "tests.c" in
-  generate_tests ();
-  close ();
+  if (!PyList_Check (obj)) {
+    PyErr_SetString (PyExc_RuntimeError, \"expecting a list parameter\");
+    return NULL;
+  }
 
-  let close = output_to "fish/cmds.c" in
-  generate_fish_cmds ();
-  close ();
+  len = PyList_Size (obj);
+  r = malloc (sizeof (char *) * (len+1));
+  if (r == NULL) {
+    PyErr_SetString (PyExc_RuntimeError, \"get_string_list: out of memory\");
+    return NULL;
+  }
 
-  let close = output_to "guestfs-structs.pod" in
-  generate_structs_pod ();
-  close ();
+  for (i = 0; i < len; ++i)
+    r[i] = PyString_AsString (PyList_GetItem (obj, i));
+  r[len] = NULL;
 
-  let close = output_to "guestfs-actions.pod" in
-  generate_actions_pod ();
-  close ();
+  return r;
+}
 
-  let close = output_to "guestfish-actions.pod" in
-  generate_fish_actions_pod ();
-  close ();
+static PyObject *
+put_string_list (char * const * const argv)
+{
+  PyObject *list;
+  int argc, i;
 
-  let close = output_to "ocaml/guestfs.mli" in
-  generate_ocaml_mli ();
-  close ();
+  for (argc = 0; argv[argc] != NULL; ++argc)
+    ;
 
-  let close = output_to "ocaml/guestfs.ml" in
-  generate_ocaml_ml ();
-  close ();
+  list = PyList_New (argc);
+  for (i = 0; i < argc; ++i)
+    PyList_SetItem (list, i, PyString_FromString (argv[i]));
 
-  let close = output_to "ocaml/guestfs_c_actions.c" in
-  generate_ocaml_c ();
-  close ();
+  return list;
+}
 
-  let close = output_to "perl/Guestfs.xs" in
-  generate_perl_xs ();
-  close ();
+static PyObject *
+put_table (char * const * const argv)
+{
+  PyObject *list, *item;
+  int argc, i;
 
-  let close = output_to "perl/lib/Sys/Guestfs.pm" in
-  generate_perl_pm ();
+  for (argc = 0; argv[argc] != NULL; ++argc)
+    ;
+
+  list = PyList_New (argc >> 1);
+  for (i = 0; i < argc; i += 2) {
+    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)
+{
+  int argc;
+
+  for (argc = 0; argv[argc] != NULL; ++argc)
+    free (argv[argc]);
+  free (argv);
+}
+
+static PyObject *
+py_guestfs_create (PyObject *self, PyObject *args)
+{
+  guestfs_h *g;
+
+  g = guestfs_create ();
+  if (g == NULL) {
+    PyErr_SetString (PyExc_RuntimeError,
+                     \"guestfs.create: failed to allocate handle\");
+    return NULL;
+  }
+  guestfs_set_error_handler (g, NULL, NULL);
+  return put_handle (g);
+}
+
+static PyObject *
+py_guestfs_close (PyObject *self, PyObject *args)
+{
+  PyObject *py_g;
+  guestfs_h *g;
+
+  if (!PyArg_ParseTuple (args, (char *) \"O:guestfs_close\", &py_g))
+    return NULL;
+  g = get_handle (py_g);
+
+  guestfs_close (g);
+
+  Py_INCREF (Py_None);
+  return Py_None;
+}
+
+";
+
+  (* LVM structures, turned into Python dictionaries. *)
+  List.iter (
+    fun (typ, cols) ->
+      pr "static PyObject *\n";
+      pr "put_lvm_%s (struct guestfs_lvm_%s *%s)\n" typ typ typ;
+      pr "{\n";
+      pr "  PyObject *dict;\n";
+      pr "\n";
+      pr "  dict = PyDict_New ();\n";
+      List.iter (
+	function
+	| name, `String ->
+	    pr "  PyDict_SetItemString (dict, \"%s\",\n" name;
+	    pr "                        PyString_FromString (%s->%s));\n"
+	      typ name
+	| name, `UUID ->
+	    pr "  PyDict_SetItemString (dict, \"%s\",\n" name;
+	    pr "                        PyString_FromStringAndSize (%s->%s, 32));\n"
+	      typ name
+	| name, `Bytes ->
+	    pr "  PyDict_SetItemString (dict, \"%s\",\n" name;
+	    pr "                        PyLong_FromUnsignedLongLong (%s->%s));\n"
+	      typ name
+	| name, `Int ->
+	    pr "  PyDict_SetItemString (dict, \"%s\",\n" name;
+	    pr "                        PyLong_FromLongLong (%s->%s));\n"
+	      typ name
+	| name, `OptPercent ->
+	    pr "  if (%s->%s >= 0)\n" typ name;
+	    pr "    PyDict_SetItemString (dict, \"%s\",\n" name;
+	    pr "                          PyFloat_FromDouble ((double) %s->%s));\n"
+	      typ name;
+	    pr "  else {\n";
+	    pr "    Py_INCREF (Py_None);\n";
+	    pr "    PyDict_SetItemString (dict, \"%s\", Py_None);" name;
+	    pr "  }\n"
+      ) cols;
+      pr "  return dict;\n";
+      pr "};\n";
+      pr "\n";
+
+      pr "static PyObject *\n";
+      pr "put_lvm_%s_list (struct guestfs_lvm_%s_list *%ss)\n" typ typ typ;
+      pr "{\n";
+      pr "  PyObject *list;\n";
+      pr "  int i;\n";
+      pr "\n";
+      pr "  list = PyList_New (%ss->len);\n" typ;
+      pr "  for (i = 0; i < %ss->len; ++i)\n" typ;
+      pr "    PyList_SetItem (list, i, put_lvm_%s (&%ss->val[i]));\n" typ typ;
+      pr "  return list;\n";
+      pr "};\n";
+      pr "\n"
+  ) ["pv", pv_cols; "vg", vg_cols; "lv", lv_cols];
+
+  (* Stat structures, turned into Python dictionaries. *)
+  List.iter (
+    fun (typ, cols) ->
+      pr "static PyObject *\n";
+      pr "put_%s (struct guestfs_%s *%s)\n" typ typ typ;
+      pr "{\n";
+      pr "  PyObject *dict;\n";
+      pr "\n";
+      pr "  dict = PyDict_New ();\n";
+      List.iter (
+	function
+	| name, `Int ->
+	    pr "  PyDict_SetItemString (dict, \"%s\",\n" name;
+	    pr "                        PyLong_FromLongLong (%s->%s));\n"
+	      typ name
+      ) cols;
+      pr "  return dict;\n";
+      pr "};\n";
+      pr "\n";
+  ) ["stat", stat_cols; "statvfs", statvfs_cols];
+
+  (* Python wrapper functions. *)
+  List.iter (
+    fun (name, style, _, _, _, _, _) ->
+      pr "static PyObject *\n";
+      pr "py_guestfs_%s (PyObject *self, PyObject *args)\n" name;
+      pr "{\n";
+
+      pr "  PyObject *py_g;\n";
+      pr "  guestfs_h *g;\n";
+      pr "  PyObject *py_r;\n";
+
+      let error_code =
+	match fst style with
+	| RErr | RInt _ | RBool _ -> pr "  int r;\n"; "-1"
+	| RInt64 _ -> pr "  int64_t r;\n"; "-1"
+	| RConstString _ -> pr "  const char *r;\n"; "NULL"
+	| RString _ -> pr "  char *r;\n"; "NULL"
+	| RStringList _ | RHashtable _ -> pr "  char **r;\n"; "NULL"
+	| RIntBool _ -> pr "  struct guestfs_int_bool *r;\n"; "NULL"
+	| RPVList n -> pr "  struct guestfs_lvm_pv_list *r;\n"; "NULL"
+	| RVGList n -> pr "  struct guestfs_lvm_vg_list *r;\n"; "NULL"
+	| RLVList n -> pr "  struct guestfs_lvm_lv_list *r;\n"; "NULL"
+	| RStat n -> pr "  struct guestfs_stat *r;\n"; "NULL"
+	| RStatVFS n -> pr "  struct guestfs_statvfs *r;\n"; "NULL" in
+
+      List.iter (
+	function
+	| String n | FileIn n | FileOut n -> pr "  const char *%s;\n" n
+	| OptString n -> pr "  const char *%s;\n" n
+	| StringList n ->
+	    pr "  PyObject *py_%s;\n" n;
+	    pr "  const char **%s;\n" n
+	| Bool n -> pr "  int %s;\n" n
+	| Int n -> pr "  int %s;\n" n
+      ) (snd style);
+
+      pr "\n";
+
+      (* Convert the parameters. *)
+      pr "  if (!PyArg_ParseTuple (args, (char *) \"O";
+      List.iter (
+	function
+	| String _ | FileIn _ | FileOut _ -> pr "s"
+	| OptString _ -> pr "z"
+	| StringList _ -> pr "O"
+	| Bool _ -> pr "i" (* XXX Python has booleans? *)
+	| Int _ -> pr "i"
+      ) (snd style);
+      pr ":guestfs_%s\",\n" name;
+      pr "                         &py_g";
+      List.iter (
+	function
+	| String n | FileIn n | FileOut n -> pr ", &%s" n
+	| OptString n -> pr ", &%s" n
+	| StringList n -> pr ", &py_%s" n
+	| Bool n -> pr ", &%s" n
+	| Int n -> pr ", &%s" n
+      ) (snd style);
+
+      pr "))\n";
+      pr "    return NULL;\n";
+
+      pr "  g = get_handle (py_g);\n";
+      List.iter (
+	function
+	| String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
+	| StringList n ->
+	    pr "  %s = get_string_list (py_%s);\n" n n;
+	    pr "  if (!%s) return NULL;\n" n
+      ) (snd style);
+
+      pr "\n";
+
+      pr "  r = guestfs_%s " name;
+      generate_call_args ~handle:"g" (snd style);
+      pr ";\n";
+
+      List.iter (
+	function
+	| String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
+	| StringList n ->
+	    pr "  free (%s);\n" n
+      ) (snd style);
+
+      pr "  if (r == %s) {\n" error_code;
+      pr "    PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));\n";
+      pr "    return NULL;\n";
+      pr "  }\n";
+      pr "\n";
+
+      (match fst style with
+       | RErr ->
+	   pr "  Py_INCREF (Py_None);\n";
+	   pr "  py_r = Py_None;\n"
+       | RInt _
+       | RBool _ -> pr "  py_r = PyInt_FromLong ((long) r);\n"
+       | RInt64 _ -> pr "  py_r = PyLong_FromLongLong (r);\n"
+       | RConstString _ -> pr "  py_r = PyString_FromString (r);\n"
+       | RString _ ->
+	   pr "  py_r = PyString_FromString (r);\n";
+	   pr "  free (r);\n"
+       | RStringList _ ->
+	   pr "  py_r = put_string_list (r);\n";
+	   pr "  free_strings (r);\n"
+       | RIntBool _ ->
+	   pr "  py_r = PyTuple_New (2);\n";
+	   pr "  PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));\n";
+	   pr "  PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));\n";
+	   pr "  guestfs_free_int_bool (r);\n"
+       | RPVList n ->
+	   pr "  py_r = put_lvm_pv_list (r);\n";
+	   pr "  guestfs_free_lvm_pv_list (r);\n"
+       | RVGList n ->
+	   pr "  py_r = put_lvm_vg_list (r);\n";
+	   pr "  guestfs_free_lvm_vg_list (r);\n"
+       | RLVList n ->
+	   pr "  py_r = put_lvm_lv_list (r);\n";
+	   pr "  guestfs_free_lvm_lv_list (r);\n"
+       | RStat n ->
+	   pr "  py_r = put_stat (r);\n";
+	   pr "  free (r);\n"
+       | RStatVFS n ->
+	   pr "  py_r = put_statvfs (r);\n";
+	   pr "  free (r);\n"
+       | RHashtable n ->
+	   pr "  py_r = put_table (r);\n";
+	   pr "  free_strings (r);\n"
+      );
+
+      pr "  return py_r;\n";
+      pr "}\n";
+      pr "\n"
+  ) all_functions;
+
+  (* Table of functions. *)
+  pr "static PyMethodDef methods[] = {\n";
+  pr "  { (char *) \"create\", py_guestfs_create, METH_VARARGS, NULL },\n";
+  pr "  { (char *) \"close\", py_guestfs_close, METH_VARARGS, NULL },\n";
+  List.iter (
+    fun (name, _, _, _, _, _, _) ->
+      pr "  { (char *) \"%s\", py_guestfs_%s, METH_VARARGS, NULL },\n"
+	name name
+  ) all_functions;
+  pr "  { NULL, NULL, 0, NULL }\n";
+  pr "};\n";
+  pr "\n";
+
+  (* Init function. *)
+  pr "\
+void
+initlibguestfsmod (void)
+{
+  static int initialized = 0;
+
+  if (initialized) return;
+  Py_InitModule ((char *) \"libguestfsmod\", methods);
+  initialized = 1;
+}
+"
+
+(* Generate Python module. *)
+and generate_python_py () =
+  generate_header HashStyle LGPLv2;
+
+  pr "\
+u\"\"\"Python bindings for libguestfs
+
+import guestfs
+g = guestfs.GuestFS ()
+g.add_drive (\"guest.img\")
+g.launch ()
+g.wait_ready ()
+parts = g.list_partitions ()
+
+The guestfs module provides a Python binding to the libguestfs API
+for examining and modifying virtual machine disk images.
+
+Amongst the things this is good for: making batch configuration
+changes to guests, getting disk used/free statistics (see also:
+virt-df), migrating between virtualization systems (see also:
+virt-p2v), performing partial backups, performing partial guest
+clones, cloning guests and changing registry/UUID/hostname info, and
+much else besides.
+
+Libguestfs uses Linux kernel and qemu code, and can access any type of
+guest filesystem that Linux and qemu can, including but not limited
+to: ext2/3/4, btrfs, FAT and NTFS, LVM, many different disk partition
+schemes, qcow, qcow2, vmdk.
+
+Libguestfs provides ways to enumerate guest storage (eg. partitions,
+LVs, what filesystem is in each LV, etc.).  It can also run commands
+in the context of the guest.  Also you can access filesystems over FTP.
+
+Errors which happen while using the API are turned into Python
+RuntimeError exceptions.
+
+To create a guestfs handle you usually have to perform the following
+sequence of calls:
+
+# Create the handle, call add_drive at least once, and possibly
+# several times if the guest has multiple block devices:
+g = guestfs.GuestFS ()
+g.add_drive (\"guest.img\")
+
+# Launch the qemu subprocess and wait for it to become ready:
+g.launch ()
+g.wait_ready ()
+
+# Now you can issue commands, for example:
+logvols = g.lvs ()
+
+\"\"\"
+
+import libguestfsmod
+
+class GuestFS:
+    \"\"\"Instances of this class are libguestfs API handles.\"\"\"
+
+    def __init__ (self):
+        \"\"\"Create a new libguestfs handle.\"\"\"
+        self._o = libguestfsmod.create ()
+
+    def __del__ (self):
+        libguestfsmod.close (self._o)
+
+";
+
+  List.iter (
+    fun (name, style, _, flags, _, _, longdesc) ->
+      let doc = replace_str longdesc "C<guestfs_" "C<g." in
+      let doc =
+        match fst style with
+	| RErr | RInt _ | RInt64 _ | RBool _ | RConstString _
+	| RString _ -> doc
+	| RStringList _ ->
+	    doc ^ "\n\nThis function returns a list of strings."
+	| RIntBool _ ->
+	    doc ^ "\n\nThis function returns a tuple (int, bool).\n"
+	| RPVList _ ->
+	    doc ^ "\n\nThis function returns a list of PVs.  Each PV is represented as a dictionary."
+	| RVGList _ ->
+	    doc ^ "\n\nThis function returns a list of VGs.  Each VG is represented as a dictionary."
+	| RLVList _ ->
+	    doc ^ "\n\nThis function returns a list of LVs.  Each LV is represented as a dictionary."
+	| RStat _ ->
+	    doc ^ "\n\nThis function returns a dictionary, with keys matching the various fields in the stat structure."
+       | RStatVFS _ ->
+	    doc ^ "\n\nThis function returns a dictionary, with keys matching the various fields in the statvfs structure."
+       | RHashtable _ ->
+	    doc ^ "\n\nThis function returns a dictionary." in
+      let doc =
+	if List.mem ProtocolLimitWarning flags then
+	  doc ^ "\n\n" ^ protocol_limit_warning
+	else doc in
+      let doc =
+	if List.mem DangerWillRobinson flags then
+	  doc ^ "\n\n" ^ danger_will_robinson
+	else doc in
+      let doc = pod2text ~width:60 name doc in
+      let doc = List.map (fun line -> replace_str line "\\" "\\\\") doc in
+      let doc = String.concat "\n        " doc in
+
+      pr "    def %s " name;
+      generate_call_args ~handle:"self" (snd style);
+      pr ":\n";
+      pr "        u\"\"\"%s\"\"\"\n" doc;
+      pr "        return libguestfsmod.%s " name;
+      generate_call_args ~handle:"self._o" (snd style);
+      pr "\n";
+      pr "\n";
+  ) all_functions
+
+(* Useful if you need the longdesc POD text as plain text.  Returns a
+ * list of lines.
+ *
+ * This is the slowest thing about autogeneration.
+ *)
+and pod2text ~width name longdesc =
+  let filename, chan = Filename.open_temp_file "gen" ".tmp" in
+  fprintf chan "=head1 %s\n\n%s\n" name longdesc;
+  close_out chan;
+  let cmd = sprintf "pod2text -w %d %s" width (Filename.quote filename) in
+  let chan = Unix.open_process_in cmd in
+  let lines = ref [] in
+  let rec loop i =
+    let line = input_line chan in
+    if i = 1 then		(* discard the first line of output *)
+      loop (i+1)
+    else (
+      let line = triml line in
+      lines := line :: !lines;
+      loop (i+1)
+    ) in
+  let lines = try loop 1 with End_of_file -> List.rev !lines in
+  Unix.unlink filename;
+  match Unix.close_process_in chan with
+  | Unix.WEXITED 0 -> lines
+  | Unix.WEXITED i ->
+      failwithf "pod2text: process exited with non-zero status (%d)" i
+  | Unix.WSIGNALED i | Unix.WSTOPPED i ->
+      failwithf "pod2text: process signalled or stopped by signal %d" i
+
+(* Generate ruby bindings. *)
+and generate_ruby_c () =
+  generate_header CStyle LGPLv2;
+
+  pr "\
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <ruby.h>
+
+#include \"guestfs.h\"
+
+#include \"extconf.h\"
+
+static VALUE m_guestfs;			/* guestfs module */
+static VALUE c_guestfs;			/* guestfs_h handle */
+static VALUE e_Error;			/* used for all errors */
+
+static void ruby_guestfs_free (void *p)
+{
+  if (!p) return;
+  guestfs_close ((guestfs_h *) p);
+}
+
+static VALUE ruby_guestfs_create (VALUE m)
+{
+  guestfs_h *g;
+
+  g = guestfs_create ();
+  if (!g)
+    rb_raise (e_Error, \"failed to create guestfs handle\");
+
+  /* Don't print error messages to stderr by default. */
+  guestfs_set_error_handler (g, NULL, NULL);
+
+  /* Wrap it, and make sure the close function is called when the
+   * handle goes away.
+   */
+  return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
+}
+
+static VALUE ruby_guestfs_close (VALUE gv)
+{
+  guestfs_h *g;
+  Data_Get_Struct (gv, guestfs_h, g);
+
+  ruby_guestfs_free (g);
+  DATA_PTR (gv) = NULL;
+
+  return Qnil;
+}
+
+";
+
+  List.iter (
+    fun (name, style, _, _, _, _, _) ->
+      pr "static VALUE ruby_guestfs_%s (VALUE gv" name;
+      List.iter (fun arg -> pr ", VALUE %sv" (name_of_argt arg)) (snd style);
+      pr ")\n";
+      pr "{\n";
+      pr "  guestfs_h *g;\n";
+      pr "  Data_Get_Struct (gv, guestfs_h, g);\n";
+      pr "  if (!g)\n";
+      pr "    rb_raise (rb_eArgError, \"%%s: used handle after closing it\", \"%s\");\n"
+	name;
+      pr "\n";
+
+      List.iter (
+	function
+	| String n | FileIn n | FileOut n ->
+	    pr "  const char *%s = StringValueCStr (%sv);\n" n n;
+	    pr "  if (!%s)\n" n;
+	    pr "    rb_raise (rb_eTypeError, \"expected string for parameter %%s of %%s\",\n";
+	    pr "              \"%s\", \"%s\");\n" n name
+	| OptString n ->
+	    pr "  const char *%s = StringValueCStr (%sv);\n" n n
+	| StringList n ->
+	    pr "  char **%s;" n;
+	    pr "  {\n";
+	    pr "    int i, len;\n";
+	    pr "    len = RARRAY_LEN (%sv);\n" n;
+	    pr "    %s = guestfs_safe_malloc (g, sizeof (char *) * (len+1));\n"
+	      n;
+	    pr "    for (i = 0; i < len; ++i) {\n";
+	    pr "      VALUE v = rb_ary_entry (%sv, i);\n" n;
+	    pr "      %s[i] = StringValueCStr (v);\n" n;
+	    pr "    }\n";
+	    pr "    %s[len] = NULL;\n" n;
+	    pr "  }\n";
+	| Bool n
+	| Int n ->
+	    pr "  int %s = NUM2INT (%sv);\n" n n
+      ) (snd style);
+      pr "\n";
+
+      let error_code =
+	match fst style with
+	| RErr | RInt _ | RBool _ -> pr "  int r;\n"; "-1"
+	| RInt64 _ -> pr "  int64_t r;\n"; "-1"
+	| RConstString _ -> pr "  const char *r;\n"; "NULL"
+	| RString _ -> pr "  char *r;\n"; "NULL"
+	| RStringList _ | RHashtable _ -> pr "  char **r;\n"; "NULL"
+	| RIntBool _ -> pr "  struct guestfs_int_bool *r;\n"; "NULL"
+	| RPVList n -> pr "  struct guestfs_lvm_pv_list *r;\n"; "NULL"
+	| RVGList n -> pr "  struct guestfs_lvm_vg_list *r;\n"; "NULL"
+	| RLVList n -> pr "  struct guestfs_lvm_lv_list *r;\n"; "NULL"
+	| RStat n -> pr "  struct guestfs_stat *r;\n"; "NULL"
+	| RStatVFS n -> pr "  struct guestfs_statvfs *r;\n"; "NULL" in
+      pr "\n";
+
+      pr "  r = guestfs_%s " name;
+      generate_call_args ~handle:"g" (snd style);
+      pr ";\n";
+
+      List.iter (
+	function
+	| String _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
+	| StringList n ->
+	    pr "  free (%s);\n" n
+      ) (snd style);
+
+      pr "  if (r == %s)\n" error_code;
+      pr "    rb_raise (e_Error, \"%%s\", guestfs_last_error (g));\n";
+      pr "\n";
+
+      (match fst style with
+       | RErr ->
+	   pr "  return Qnil;\n"
+       | RInt _ | RBool _ ->
+	   pr "  return INT2NUM (r);\n"
+       | RInt64 _ ->
+	   pr "  return ULL2NUM (r);\n"
+       | RConstString _ ->
+	   pr "  return rb_str_new2 (r);\n";
+       | RString _ ->
+	   pr "  VALUE rv = rb_str_new2 (r);\n";
+	   pr "  free (r);\n";
+	   pr "  return rv;\n";
+       | RStringList _ ->
+	   pr "  int i, len = 0;\n";
+	   pr "  for (i = 0; r[i] != NULL; ++i) len++;\n";
+	   pr "  VALUE rv = rb_ary_new2 (len);\n";
+	   pr "  for (i = 0; r[i] != NULL; ++i) {\n";
+	   pr "    rb_ary_push (rv, rb_str_new2 (r[i]));\n";
+	   pr "    free (r[i]);\n";
+	   pr "  }\n";
+	   pr "  free (r);\n";
+	   pr "  return rv;\n"
+       | RIntBool _ ->
+	   pr "  VALUE rv = rb_ary_new2 (2);\n";
+	   pr "  rb_ary_push (rv, INT2NUM (r->i));\n";
+	   pr "  rb_ary_push (rv, INT2NUM (r->b));\n";
+	   pr "  guestfs_free_int_bool (r);\n";
+	   pr "  return rv;\n"
+       | RPVList n ->
+	   generate_ruby_lvm_code "pv" pv_cols
+       | RVGList n ->
+	   generate_ruby_lvm_code "vg" vg_cols
+       | RLVList n ->
+	   generate_ruby_lvm_code "lv" lv_cols
+       | RStat n ->
+	   pr "  VALUE rv = rb_hash_new ();\n";
+	   List.iter (
+	     function
+	     | name, `Int ->
+		 pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->%s));\n" name name
+	   ) stat_cols;
+	   pr "  free (r);\n";
+	   pr "  return rv;\n"
+       | RStatVFS n ->
+	   pr "  VALUE rv = rb_hash_new ();\n";
+	   List.iter (
+	     function
+	     | name, `Int ->
+		 pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->%s));\n" name name
+	   ) statvfs_cols;
+	   pr "  free (r);\n";
+	   pr "  return rv;\n"
+       | RHashtable _ ->
+	   pr "  VALUE rv = rb_hash_new ();\n";
+	   pr "  int i;\n";
+	   pr "  for (i = 0; r[i] != NULL; i+=2) {\n";
+	   pr "    rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));\n";
+	   pr "    free (r[i]);\n";
+	   pr "    free (r[i+1]);\n";
+	   pr "  }\n";
+	   pr "  free (r);\n";
+	   pr "  return rv;\n"
+      );
+
+      pr "}\n";
+      pr "\n"
+  ) all_functions;
+
+  pr "\
+/* Initialize the module. */
+void Init__guestfs ()
+{
+  m_guestfs = rb_define_module (\"Guestfs\");
+  c_guestfs = rb_define_class_under (m_guestfs, \"Guestfs\", rb_cObject);
+  e_Error = rb_define_class_under (m_guestfs, \"Error\", rb_eStandardError);
+
+  rb_define_module_function (m_guestfs, \"create\", ruby_guestfs_create, 0);
+  rb_define_method (c_guestfs, \"close\", ruby_guestfs_close, 0);
+
+";
+  (* Define the rest of the methods. *)
+  List.iter (
+    fun (name, style, _, _, _, _, _) ->
+      pr "  rb_define_method (c_guestfs, \"%s\",\n" name;
+      pr "        ruby_guestfs_%s, %d);\n" name (List.length (snd style))
+  ) all_functions;
+
+  pr "}\n"
+
+(* Ruby code to return an LVM struct list. *)
+and generate_ruby_lvm_code typ cols =
+  pr "  VALUE rv = rb_ary_new2 (r->len);\n";
+  pr "  int i;\n";
+  pr "  for (i = 0; i < r->len; ++i) {\n";
+  pr "    VALUE hv = rb_hash_new ();\n";
+  List.iter (
+    function
+    | name, `String ->
+	pr "    rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new2 (r->val[i].%s));\n" name name
+    | name, `UUID ->
+	pr "    rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new (r->val[i].%s, 32));\n" name name
+    | name, `Bytes
+    | name, `Int ->
+	pr "    rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->val[i].%s));\n" name name
+    | name, `OptPercent ->
+	pr "    rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_dbl2big (r->val[i].%s));\n" name name
+  ) cols;
+  pr "    rb_ary_push (rv, hv);\n";
+  pr "  }\n";
+  pr "  guestfs_free_lvm_%s_list (r);\n" typ;
+  pr "  return rv;\n"
+
+(* Generate Java bindings GuestFS.java file. *)
+and generate_java_java () =
+  generate_header CStyle LGPLv2;
+
+  pr "\
+package com.redhat.et.libguestfs;
+
+import java.util.HashMap;
+import com.redhat.et.libguestfs.LibGuestFSException;
+import com.redhat.et.libguestfs.PV;
+import com.redhat.et.libguestfs.VG;
+import com.redhat.et.libguestfs.LV;
+import com.redhat.et.libguestfs.Stat;
+import com.redhat.et.libguestfs.StatVFS;
+import com.redhat.et.libguestfs.IntBool;
+
+/**
+ * The GuestFS object is a libguestfs handle.
+ *
+ * @author rjones
+ */
+public class GuestFS {
+  // Load the native code.
+  static {
+    System.loadLibrary (\"guestfs_jni\");
+  }
+
+  /**
+   * The native guestfs_h pointer.
+   */
+  long g;
+
+  /**
+   * Create a libguestfs handle.
+   *
+   * @throws LibGuestFSException
+   */
+  public GuestFS () throws LibGuestFSException
+  {
+    g = _create ();
+  }
+  private native long _create () throws LibGuestFSException;
+
+  /**
+   * Close a libguestfs handle.
+   *
+   * You can also leave handles to be collected by the garbage
+   * collector, but this method ensures that the resources used
+   * by the handle are freed up immediately.  If you call any
+   * other methods after closing the handle, you will get an
+   * exception.
+   *
+   * @throws LibGuestFSException
+   */
+  public void close () throws LibGuestFSException
+  {
+    if (g != 0)
+      _close (g);
+    g = 0;
+  }
+  private native void _close (long g) throws LibGuestFSException;
+
+  public void finalize () throws LibGuestFSException
+  {
+    close ();
+  }
+
+";
+
+  List.iter (
+    fun (name, style, _, flags, _, shortdesc, longdesc) ->
+      let doc = replace_str longdesc "C<guestfs_" "C<g." in
+      let doc =
+	if List.mem ProtocolLimitWarning flags then
+	  doc ^ "\n\n" ^ protocol_limit_warning
+	else doc in
+      let doc =
+	if List.mem DangerWillRobinson flags then
+	  doc ^ "\n\n" ^ danger_will_robinson
+	else doc in
+      let doc = pod2text ~width:60 name doc in
+      let doc = String.concat "\n   * " doc in
+
+      pr "  /**\n";
+      pr "   * %s\n" shortdesc;
+      pr "   *\n";
+      pr "   * %s\n" doc;
+      pr "   * @throws LibGuestFSException\n";
+      pr "   */\n";
+      pr "  ";
+      generate_java_prototype ~public:true ~semicolon:false name style;
+      pr "\n";
+      pr "  {\n";
+      pr "    if (g == 0)\n";
+      pr "      throw new LibGuestFSException (\"%s: handle is closed\");\n"
+	name;
+      pr "    ";
+      if fst style <> RErr then pr "return ";
+      pr "_%s " name;
+      generate_call_args ~handle:"g" (snd style);
+      pr ";\n";
+      pr "  }\n";
+      pr "  ";
+      generate_java_prototype ~privat:true ~native:true name style;
+      pr "\n";
+      pr "\n";
+  ) all_functions;
+
+  pr "}\n"
+
+and generate_java_prototype ?(public=false) ?(privat=false) ?(native=false)
+    ?(semicolon=true) name style =
+  if privat then pr "private ";
+  if public then pr "public ";
+  if native then pr "native ";
+
+  (* return type *)
+  (match fst style with
+   | RErr -> pr "void ";
+   | RInt _ -> pr "int ";
+   | RInt64 _ -> pr "long ";
+   | RBool _ -> pr "boolean ";
+   | RConstString _ | RString _ -> pr "String ";
+   | RStringList _ -> pr "String[] ";
+   | RIntBool _ -> pr "IntBool ";
+   | RPVList _ -> pr "PV[] ";
+   | RVGList _ -> pr "VG[] ";
+   | RLVList _ -> pr "LV[] ";
+   | RStat _ -> pr "Stat ";
+   | RStatVFS _ -> pr "StatVFS ";
+   | RHashtable _ -> pr "HashMap<String,String> ";
+  );
+
+  if native then pr "_%s " name else pr "%s " name;
+  pr "(";
+  let needs_comma = ref false in
+  if native then (
+    pr "long g";
+    needs_comma := true
+  );
+
+  (* args *)
+  List.iter (
+    fun arg ->
+      if !needs_comma then pr ", ";
+      needs_comma := true;
+
+      match arg with
+      | String n
+      | OptString n
+      | FileIn n
+      | FileOut n ->
+	  pr "String %s" n
+      | StringList n ->
+	  pr "String[] %s" n
+      | Bool n ->
+	  pr "boolean %s" n
+      | Int n ->
+	  pr "int %s" n
+  ) (snd style);
+
+  pr ")\n";
+  pr "    throws LibGuestFSException";
+  if semicolon then pr ";"
+
+and generate_java_struct typ cols =
+  generate_header CStyle LGPLv2;
+
+  pr "\
+package com.redhat.et.libguestfs;
+
+/**
+ * Libguestfs %s structure.
+ *
+ * @author rjones
+ * @see GuestFS
+ */
+public class %s {
+" typ typ;
+
+  List.iter (
+    function
+    | name, `String
+    | name, `UUID -> pr "  public String %s;\n" name
+    | name, `Bytes
+    | name, `Int -> pr "  public long %s;\n" name
+    | name, `OptPercent ->
+	pr "  /* The next field is [0..100] or -1 meaning 'not present': */\n";
+	pr "  public float %s;\n" name
+  ) cols;
+
+  pr "}\n"
+
+and generate_java_c () =
+  generate_header CStyle LGPLv2;
+
+  pr "\
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include \"com_redhat_et_libguestfs_GuestFS.h\"
+#include \"guestfs.h\"
+
+/* Note that this function returns.  The exception is not thrown
+ * until after the wrapper function returns.
+ */
+static void
+throw_exception (JNIEnv *env, const char *msg)
+{
+  jclass cl;
+  cl = (*env)->FindClass (env,
+                          \"com/redhat/et/libguestfs/LibGuestFSException\");
+  (*env)->ThrowNew (env, cl, msg);
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1create
+  (JNIEnv *env, jobject obj)
+{
+  guestfs_h *g;
+
+  g = guestfs_create ();
+  if (g == NULL) {
+    throw_exception (env, \"GuestFS.create: failed to allocate handle\");
+    return 0;
+  }
+  guestfs_set_error_handler (g, NULL, NULL);
+  return (jlong) (long) g;
+}
+
+JNIEXPORT void JNICALL
+Java_com_redhat_et_libguestfs_GuestFS__1close
+  (JNIEnv *env, jobject obj, jlong jg)
+{
+  guestfs_h *g = (guestfs_h *) (long) jg;
+  guestfs_close (g);
+}
+
+";
+
+  List.iter (
+    fun (name, style, _, _, _, _, _) ->
+      pr "JNIEXPORT ";
+      (match fst style with
+       | RErr -> pr "void ";
+       | RInt _ -> pr "jint ";
+       | RInt64 _ -> pr "jlong ";
+       | RBool _ -> pr "jboolean ";
+       | RConstString _ | RString _ -> pr "jstring ";
+       | RIntBool _ | RStat _ | RStatVFS _ | RHashtable _ ->
+	   pr "jobject ";
+       | RStringList _ | RPVList _ | RVGList _ | RLVList _ ->
+	   pr "jobjectArray ";
+      );
+      pr "JNICALL\n";
+      pr "Java_com_redhat_et_libguestfs_GuestFS_";
+      pr "%s" (replace_str ("_" ^ name) "_" "_1");
+      pr "\n";
+      pr "  (JNIEnv *env, jobject obj, jlong jg";
+      List.iter (
+	function
+	| String n
+	| OptString n
+	| FileIn n
+	| FileOut n ->
+	    pr ", jstring j%s" n
+	| StringList n ->
+	    pr ", jobjectArray j%s" n
+	| Bool n ->
+	    pr ", jboolean j%s" n
+	| Int n ->
+	    pr ", jint j%s" n
+      ) (snd style);
+      pr ")\n";
+      pr "{\n";
+      pr "  guestfs_h *g = (guestfs_h *) (long) jg;\n";
+      let error_code, no_ret =
+	match fst style with
+	| RErr -> pr "  int r;\n"; "-1", ""
+	| RBool _
+	| RInt _ -> pr "  int r;\n"; "-1", "0"
+	| RInt64 _ -> pr "  int64_t r;\n"; "-1", "0"
+	| RConstString _ -> pr "  const char *r;\n"; "NULL", "NULL"
+	| RString _ ->
+	    pr "  jstring jr;\n";
+	    pr "  char *r;\n"; "NULL", "NULL"
+	| RStringList _ ->
+	    pr "  jobjectArray jr;\n";
+	    pr "  int r_len;\n";
+	    pr "  jclass cl;\n";
+	    pr "  jstring jstr;\n";
+	    pr "  char **r;\n"; "NULL", "NULL"
+	| RIntBool _ ->
+	    pr "  jobject jr;\n";
+	    pr "  jclass cl;\n";
+	    pr "  jfieldID fl;\n";
+	    pr "  struct guestfs_int_bool *r;\n"; "NULL", "NULL"
+	| RStat _ ->
+	    pr "  jobject jr;\n";
+	    pr "  jclass cl;\n";
+	    pr "  jfieldID fl;\n";
+	    pr "  struct guestfs_stat *r;\n"; "NULL", "NULL"
+	| RStatVFS _ ->
+	    pr "  jobject jr;\n";
+	    pr "  jclass cl;\n";
+	    pr "  jfieldID fl;\n";
+	    pr "  struct guestfs_statvfs *r;\n"; "NULL", "NULL"
+	| RPVList _ ->
+	    pr "  jobjectArray jr;\n";
+	    pr "  jclass cl;\n";
+	    pr "  jfieldID fl;\n";
+	    pr "  jobject jfl;\n";
+	    pr "  struct guestfs_lvm_pv_list *r;\n"; "NULL", "NULL"
+	| RVGList _ ->
+	    pr "  jobjectArray jr;\n";
+	    pr "  jclass cl;\n";
+	    pr "  jfieldID fl;\n";
+	    pr "  jobject jfl;\n";
+	    pr "  struct guestfs_lvm_vg_list *r;\n"; "NULL", "NULL"
+	| RLVList _ ->
+	    pr "  jobjectArray jr;\n";
+	    pr "  jclass cl;\n";
+	    pr "  jfieldID fl;\n";
+	    pr "  jobject jfl;\n";
+	    pr "  struct guestfs_lvm_lv_list *r;\n"; "NULL", "NULL"
+	| RHashtable _ -> pr "  char **r;\n"; "NULL", "NULL" in
+      List.iter (
+	function
+	| String n
+	| OptString n
+	| FileIn n
+	| FileOut n ->
+	    pr "  const char *%s;\n" n
+	| StringList n ->
+	    pr "  int %s_len;\n" n;
+	    pr "  const char **%s;\n" n
+	| Bool n
+	| Int n ->
+	    pr "  int %s;\n" n
+      ) (snd style);
+
+      let needs_i =
+	(match fst style with
+	 | RStringList _ | RPVList _ | RVGList _ | RLVList _ -> true
+	 | RErr _ | RBool _ | RInt _ | RInt64 _ | RConstString _
+	 | RString _ | RIntBool _ | RStat _ | RStatVFS _
+	 | RHashtable _ -> false) ||
+	List.exists (function StringList _ -> true | _ -> false) (snd style) in
+      if needs_i then
+	pr "  int i;\n";
+
+      pr "\n";
+
+      (* Get the parameters. *)
+      List.iter (
+	function
+	| String n
+	| OptString n
+	| FileIn n
+	| FileOut n ->
+	    pr "  %s = (*env)->GetStringUTFChars (env, j%s, NULL);\n" n n
+	| StringList n ->
+	    pr "  %s_len = (*env)->GetArrayLength (env, j%s);\n" n n;
+	    pr "  %s = guestfs_safe_malloc (g, sizeof (char *) * (%s_len+1));\n" n n;
+	    pr "  for (i = 0; i < %s_len; ++i) {\n" n;
+	    pr "    jobject o = (*env)->GetObjectArrayElement (env, j%s, i);\n"
+	      n;
+	    pr "    %s[i] = (*env)->GetStringUTFChars (env, o, NULL);\n" n;
+	    pr "  }\n";
+	    pr "  %s[%s_len] = NULL;\n" n n;
+	| Bool n
+	| Int n ->
+	    pr "  %s = j%s;\n" n n
+      ) (snd style);
+
+      (* Make the call. *)
+      pr "  r = guestfs_%s " name;
+      generate_call_args ~handle:"g" (snd style);
+      pr ";\n";
+
+      (* Release the parameters. *)
+      List.iter (
+	function
+	| String n
+	| OptString n
+	| FileIn n
+	| FileOut n ->
+	    pr "  (*env)->ReleaseStringUTFChars (env, j%s, %s);\n" n n
+	| StringList n ->
+	    pr "  for (i = 0; i < %s_len; ++i) {\n" n;
+	    pr "    jobject o = (*env)->GetObjectArrayElement (env, j%s, i);\n"
+	      n;
+	    pr "    (*env)->ReleaseStringUTFChars (env, o, %s[i]);\n" n;
+	    pr "  }\n";
+	    pr "  free (%s);\n" n
+	| Bool n
+	| Int n -> ()
+      ) (snd style);
+
+      (* Check for errors. *)
+      pr "  if (r == %s) {\n" error_code;
+      pr "    throw_exception (env, guestfs_last_error (g));\n";
+      pr "    return %s;\n" no_ret;
+      pr "  }\n";
+
+      (* Return value. *)
+      (match fst style with
+       | RErr -> ()
+       | RInt _ -> pr "  return (jint) r;\n"
+       | RBool _ -> pr "  return (jboolean) r;\n"
+       | RInt64 _ -> pr "  return (jlong) r;\n"
+       | RConstString _ -> pr "  return (*env)->NewStringUTF (env, r);\n"
+       | RString _ ->
+	   pr "  jr = (*env)->NewStringUTF (env, r);\n";
+	   pr "  free (r);\n";
+	   pr "  return jr;\n"
+       | RStringList _ ->
+	   pr "  for (r_len = 0; r[r_len] != NULL; ++r_len) ;\n";
+	   pr "  cl = (*env)->FindClass (env, \"java/lang/String\");\n";
+	   pr "  jstr = (*env)->NewStringUTF (env, \"\");\n";
+	   pr "  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);\n";
+	   pr "  for (i = 0; i < r_len; ++i) {\n";
+	   pr "    jstr = (*env)->NewStringUTF (env, r[i]);\n";
+	   pr "    (*env)->SetObjectArrayElement (env, jr, i, jstr);\n";
+	   pr "    free (r[i]);\n";
+	   pr "  }\n";
+	   pr "  free (r);\n";
+	   pr "  return jr;\n"
+       | RIntBool _ ->
+	   pr "  cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/IntBool\");\n";
+	   pr "  jr = (*env)->AllocObject (env, cl);\n";
+	   pr "  fl = (*env)->GetFieldID (env, cl, \"i\", \"I\");\n";
+	   pr "  (*env)->SetIntField (env, jr, fl, r->i);\n";
+	   pr "  fl = (*env)->GetFieldID (env, cl, \"i\", \"Z\");\n";
+	   pr "  (*env)->SetBooleanField (env, jr, fl, r->b);\n";
+	   pr "  guestfs_free_int_bool (r);\n";
+	   pr "  return jr;\n"
+       | RStat _ ->
+	   pr "  cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/Stat\");\n";
+	   pr "  jr = (*env)->AllocObject (env, cl);\n";
+	   List.iter (
+	     function
+	     | name, `Int ->
+		 pr "  fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n"
+		   name;
+		 pr "  (*env)->SetLongField (env, jr, fl, r->%s);\n" name;
+	   ) stat_cols;
+	   pr "  free (r);\n";
+	   pr "  return jr;\n"
+       | RStatVFS _ ->
+	   pr "  cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/StatVFS\");\n";
+	   pr "  jr = (*env)->AllocObject (env, cl);\n";
+	   List.iter (
+	     function
+	     | name, `Int ->
+		 pr "  fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n"
+		   name;
+		 pr "  (*env)->SetLongField (env, jr, fl, r->%s);\n" name;
+	   ) statvfs_cols;
+	   pr "  free (r);\n";
+	   pr "  return jr;\n"
+       | RPVList _ ->
+	   generate_java_lvm_return "pv" "PV" pv_cols
+       | RVGList _ ->
+	   generate_java_lvm_return "vg" "VG" vg_cols
+       | RLVList _ ->
+	   generate_java_lvm_return "lv" "LV" lv_cols
+       | RHashtable _ ->
+	   (* XXX *)
+	   pr "  throw_exception (env, \"%s: internal error: please let us know how to make a Java HashMap from JNI bindings!\");\n" name;
+	   pr "  return NULL;\n"
+      );
+
+      pr "}\n";
+      pr "\n"
+  ) all_functions
+
+and generate_java_lvm_return typ jtyp cols =
+  pr "  cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/%s\");\n" jtyp;
+  pr "  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);\n";
+  pr "  for (i = 0; i < r->len; ++i) {\n";
+  pr "    jfl = (*env)->AllocObject (env, cl);\n";
+  List.iter (
+    function
+    | name, `String ->
+	pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
+	pr "    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].%s));\n" name;
+    | name, `UUID ->
+	pr "    {\n";
+	pr "      char s[33];\n";
+	pr "      memcpy (s, r->val[i].%s, 32);\n" name;
+	pr "      s[32] = 0;\n";
+	pr "      fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
+	pr "      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));\n";
+	pr "    }\n";
+    | name, (`Bytes|`Int) ->
+	pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n" name;
+	pr "    (*env)->SetLongField (env, jfl, fl, r->val[i].%s);\n" name;
+    | name, `OptPercent ->
+	pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"F\");\n" name;
+	pr "    (*env)->SetFloatField (env, jfl, fl, r->val[i].%s);\n" name;
+  ) cols;
+  pr "    (*env)->SetObjectArrayElement (env, jfl, i, jfl);\n";
+  pr "  }\n";
+  pr "  guestfs_free_lvm_%s_list (r);\n" typ;
+  pr "  return jr;\n"
+
+let output_to filename =
+  let filename_new = filename ^ ".new" in
+  chan := open_out filename_new;
+  let close () =
+    close_out !chan;
+    chan := stdout;
+    Unix.rename filename_new filename;
+    printf "written %s\n%!" filename;
+  in
+  close
+
+(* Main program. *)
+let () =
+  check_functions ();
+
+  if not (Sys.file_exists "configure.ac") then (
+    eprintf "\
+You are probably running this from the wrong directory.
+Run it from the top source directory using the command
+  src/generator.ml
+";
+    exit 1
+  );
+
+  let close = output_to "src/guestfs_protocol.x" in
+  generate_xdr ();
+  close ();
+
+  let close = output_to "src/guestfs-structs.h" in
+  generate_structs_h ();
+  close ();
+
+  let close = output_to "src/guestfs-actions.h" in
+  generate_actions_h ();
+  close ();
+
+  let close = output_to "src/guestfs-actions.c" in
+  generate_client_actions ();
+  close ();
+
+  let close = output_to "daemon/actions.h" in
+  generate_daemon_actions_h ();
+  close ();
+
+  let close = output_to "daemon/stubs.c" in
+  generate_daemon_actions ();
+  close ();
+
+  let close = output_to "tests.c" in
+  generate_tests ();
+  close ();
+
+  let close = output_to "fish/cmds.c" in
+  generate_fish_cmds ();
+  close ();
+
+  let close = output_to "fish/completion.c" in
+  generate_fish_completion ();
+  close ();
+
+  let close = output_to "guestfs-structs.pod" in
+  generate_structs_pod ();
+  close ();
+
+  let close = output_to "guestfs-actions.pod" in
+  generate_actions_pod ();
+  close ();
+
+  let close = output_to "guestfish-actions.pod" in
+  generate_fish_actions_pod ();
+  close ();
+
+  let close = output_to "ocaml/guestfs.mli" in
+  generate_ocaml_mli ();
+  close ();
+
+  let close = output_to "ocaml/guestfs.ml" in
+  generate_ocaml_ml ();
+  close ();
+
+  let close = output_to "ocaml/guestfs_c_actions.c" in
+  generate_ocaml_c ();
+  close ();
+
+  let close = output_to "perl/Guestfs.xs" in
+  generate_perl_xs ();
+  close ();
+
+  let close = output_to "perl/lib/Sys/Guestfs.pm" in
+  generate_perl_pm ();
+  close ();
+
+  let close = output_to "python/guestfs-py.c" in
+  generate_python_c ();
+  close ();
+
+  let close = output_to "python/guestfs.py" in
+  generate_python_py ();
+  close ();
+
+  let close = output_to "ruby/ext/guestfs/_guestfs.c" in
+  generate_ruby_c ();
+  close ();
+
+  let close = output_to "java/com/redhat/et/libguestfs/GuestFS.java" in
+  generate_java_java ();
+  close ();
+
+  let close = output_to "java/com/redhat/et/libguestfs/PV.java" in
+  generate_java_struct "PV" pv_cols;
+  close ();
+
+  let close = output_to "java/com/redhat/et/libguestfs/VG.java" in
+  generate_java_struct "VG" vg_cols;
+  close ();
+
+  let close = output_to "java/com/redhat/et/libguestfs/LV.java" in
+  generate_java_struct "LV" lv_cols;
+  close ();
+
+  let close = output_to "java/com/redhat/et/libguestfs/Stat.java" in
+  generate_java_struct "Stat" stat_cols;
+  close ();
+
+  let close = output_to "java/com/redhat/et/libguestfs/StatVFS.java" in
+  generate_java_struct "StatVFS" statvfs_cols;
+  close ();
+
+  let close = output_to "java/com_redhat_et_libguestfs_GuestFS.c" in
+  generate_java_c ();
   close ();