Added test suite.

2 files changed, 414 insertions, 73 deletions

diff --git a/perl/Guestfs.xs b/perl/Guestfs.xs
index d5f1da6b..0f72c282 100644
--- a/perl/Guestfs.xs
+++ b/perl/Guestfs.xs
@@ -73,6 +73,35 @@ error_handler (guestfs_h *g,
   last_error = strdup (msg);
 }
 
+/* http://www.perlmonks.org/?node_id=680842 */
+static char **
+XS_unpack_charPtrPtr (SV *arg) {
+  char **ret;
+  AV *av;
+  I32 i;
+
+  if (!arg || !SvOK (arg) || !SvROK (arg) || SvTYPE (SvRV (arg)) != SVt_PVAV) {
+    croak ("array reference expected");
+  }
+
+  av = (AV *)SvRV (arg);
+  ret = (char **)malloc (av_len (av) + 1 + 1);
+
+  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 + 1] = NULL;
+
+  return ret;
+}
+
 MODULE = Sys::Guestfs  PACKAGE = Sys::Guestfs
 
 guestfs_h *
@@ -95,38 +124,43 @@ void
 launch (g)
       guestfs_h *g;
  PPCODE:
-      if (guestfs_launch (g) == -1)
+      if (guestfs_launch (g) == -1) {
         croak ("launch: %s", last_error);
+      }
 
 void
 wait_ready (g)
       guestfs_h *g;
  PPCODE:
-      if (guestfs_wait_ready (g) == -1)
+      if (guestfs_wait_ready (g) == -1) {
         croak ("wait_ready: %s", last_error);
+      }
 
 void
 kill_subprocess (g)
       guestfs_h *g;
  PPCODE:
-      if (guestfs_kill_subprocess (g) == -1)
+      if (guestfs_kill_subprocess (g) == -1) {
         croak ("kill_subprocess: %s", last_error);
+      }
 
 void
 add_drive (g, filename)
       guestfs_h *g;
       char *filename;
  PPCODE:
-      if (guestfs_add_drive (g, filename) == -1)
+      if (guestfs_add_drive (g, filename) == -1) {
         croak ("add_drive: %s", last_error);
+      }
 
 void
 add_cdrom (g, filename)
       guestfs_h *g;
       char *filename;
  PPCODE:
-      if (guestfs_add_cdrom (g, filename) == -1)
+      if (guestfs_add_cdrom (g, filename) == -1) {
         croak ("add_cdrom: %s", last_error);
+      }
 
 void
 config (g, qemuparam, qemuvalue)
@@ -134,16 +168,18 @@ config (g, qemuparam, qemuvalue)
       char *qemuparam;
       char *qemuvalue;
  PPCODE:
-      if (guestfs_config (g, qemuparam, qemuvalue) == -1)
+      if (guestfs_config (g, qemuparam, qemuvalue) == -1) {
         croak ("config: %s", last_error);
+      }
 
 void
 set_path (g, path)
       guestfs_h *g;
       char *path;
  PPCODE:
-      if (guestfs_set_path (g, path) == -1)
+      if (guestfs_set_path (g, path) == -1) {
         croak ("set_path: %s", last_error);
+      }
 
 SV *
 get_path (g)
@@ -152,8 +188,9 @@ PREINIT:
       const char *path;
    CODE:
       path = guestfs_get_path (g);
-      if (path == NULL)
+      if (path == NULL) {
         croak ("get_path: %s", last_error);
+      }
       RETVAL = newSVpv (path, 0);
  OUTPUT:
       RETVAL
@@ -163,8 +200,9 @@ set_autosync (g, autosync)
       guestfs_h *g;
       int autosync;
  PPCODE:
-      if (guestfs_set_autosync (g, autosync) == -1)
+      if (guestfs_set_autosync (g, autosync) == -1) {
         croak ("set_autosync: %s", last_error);
+      }
 
 SV *
 get_autosync (g)
@@ -173,8 +211,9 @@ PREINIT:
       int autosync;
    CODE:
       autosync = guestfs_get_autosync (g);
-      if (autosync == -1)
+      if (autosync == -1) {
         croak ("get_autosync: %s", last_error);
+      }
       RETVAL = newSViv (autosync);
  OUTPUT:
       RETVAL
@@ -184,8 +223,9 @@ set_verbose (g, verbose)
       guestfs_h *g;
       int verbose;
  PPCODE:
-      if (guestfs_set_verbose (g, verbose) == -1)
+      if (guestfs_set_verbose (g, verbose) == -1) {
         croak ("set_verbose: %s", last_error);
+      }
 
 SV *
 get_verbose (g)
@@ -194,8 +234,9 @@ PREINIT:
       int verbose;
    CODE:
       verbose = guestfs_get_verbose (g);
-      if (verbose == -1)
+      if (verbose == -1) {
         croak ("get_verbose: %s", last_error);
+      }
       RETVAL = newSViv (verbose);
  OUTPUT:
       RETVAL
@@ -206,23 +247,26 @@ mount (g, device, mountpoint)
       char *device;
       char *mountpoint;
  PPCODE:
-      if (guestfs_mount (g, device, mountpoint) == -1)
+      if (guestfs_mount (g, device, mountpoint) == -1) {
         croak ("mount: %s", last_error);
+      }
 
 void
 sync (g)
       guestfs_h *g;
  PPCODE:
-      if (guestfs_sync (g) == -1)
+      if (guestfs_sync (g) == -1) {
         croak ("sync: %s", last_error);
+      }
 
 void
 touch (g, path)
       guestfs_h *g;
       char *path;
  PPCODE:
-      if (guestfs_touch (g, path) == -1)
+      if (guestfs_touch (g, path) == -1) {
         croak ("touch: %s", last_error);
+      }
 
 SV *
 cat (g, path)
@@ -232,8 +276,9 @@ PREINIT:
       char *content;
    CODE:
       content = guestfs_cat (g, path);
-      if (content == NULL)
+      if (content == NULL) {
         croak ("cat: %s", last_error);
+      }
       RETVAL = newSVpv (content, 0);
       free (content);
  OUTPUT:
@@ -247,8 +292,9 @@ PREINIT:
       char *listing;
    CODE:
       listing = guestfs_ll (g, directory);
-      if (listing == NULL)
+      if (listing == NULL) {
         croak ("ll: %s", last_error);
+      }
       RETVAL = newSVpv (listing, 0);
       free (listing);
  OUTPUT:
@@ -263,8 +309,9 @@ PREINIT:
       int i, n;
  PPCODE:
       listing = guestfs_ls (g, directory);
-      if (listing == NULL)
+      if (listing == NULL) {
         croak ("ls: %s", last_error);
+      }
       for (n = 0; listing[n] != NULL; ++n) /**/;
       EXTEND (SP, n);
       for (i = 0; i < n; ++i) {
@@ -281,8 +328,9 @@ PREINIT:
       int i, n;
  PPCODE:
       devices = guestfs_list_devices (g);
-      if (devices == NULL)
+      if (devices == NULL) {
         croak ("list_devices: %s", last_error);
+      }
       for (n = 0; devices[n] != NULL; ++n) /**/;
       EXTEND (SP, n);
       for (i = 0; i < n; ++i) {
@@ -299,8 +347,9 @@ PREINIT:
       int i, n;
  PPCODE:
       partitions = guestfs_list_partitions (g);
-      if (partitions == NULL)
+      if (partitions == NULL) {
         croak ("list_partitions: %s", last_error);
+      }
       for (n = 0; partitions[n] != NULL; ++n) /**/;
       EXTEND (SP, n);
       for (i = 0; i < n; ++i) {
@@ -317,8 +366,9 @@ PREINIT:
       int i, n;
  PPCODE:
       physvols = guestfs_pvs (g);
-      if (physvols == NULL)
+      if (physvols == NULL) {
         croak ("pvs: %s", last_error);
+      }
       for (n = 0; physvols[n] != NULL; ++n) /**/;
       EXTEND (SP, n);
       for (i = 0; i < n; ++i) {
@@ -335,8 +385,9 @@ PREINIT:
       int i, n;
  PPCODE:
       volgroups = guestfs_vgs (g);
-      if (volgroups == NULL)
+      if (volgroups == NULL) {
         croak ("vgs: %s", last_error);
+      }
       for (n = 0; volgroups[n] != NULL; ++n) /**/;
       EXTEND (SP, n);
       for (i = 0; i < n; ++i) {
@@ -353,8 +404,9 @@ PREINIT:
       int i, n;
  PPCODE:
       logvols = guestfs_lvs (g);
-      if (logvols == NULL)
+      if (logvols == NULL) {
         croak ("lvs: %s", last_error);
+      }
       for (n = 0; logvols[n] != NULL; ++n) /**/;
       EXTEND (SP, n);
       for (i = 0; i < n; ++i) {
@@ -475,8 +527,9 @@ PREINIT:
       int i, n;
  PPCODE:
       lines = guestfs_read_lines (g, path);
-      if (lines == NULL)
+      if (lines == NULL) {
         croak ("read_lines: %s", last_error);
+      }
       for (n = 0; lines[n] != NULL; ++n) /**/;
       EXTEND (SP, n);
       for (i = 0; i < n; ++i) {
@@ -491,15 +544,17 @@ aug_init (g, root, flags)
       char *root;
       int flags;
  PPCODE:
-      if (guestfs_aug_init (g, root, flags) == -1)
+      if (guestfs_aug_init (g, root, flags) == -1) {
         croak ("aug_init: %s", last_error);
+      }
 
 void
 aug_close (g)
       guestfs_h *g;
  PPCODE:
-      if (guestfs_aug_close (g) == -1)
+      if (guestfs_aug_close (g) == -1) {
         croak ("aug_close: %s", last_error);
+      }
 
 SV *
 aug_defvar (g, name, expr)
@@ -510,8 +565,9 @@ PREINIT:
       int nrnodes;
    CODE:
       nrnodes = guestfs_aug_defvar (g, name, expr);
-      if (nrnodes == -1)
+      if (nrnodes == -1) {
         croak ("aug_defvar: %s", last_error);
+      }
       RETVAL = newSViv (nrnodes);
  OUTPUT:
       RETVAL
@@ -526,8 +582,9 @@ PREINIT:
       struct guestfs_int_bool *r;
  PPCODE:
       r = guestfs_aug_defnode (g, name, expr, val);
-      if (r == NULL)
+      if (r == NULL) {
         croak ("aug_defnode: %s", last_error);
+      }
       EXTEND (SP, 2);
       PUSHs (sv_2mortal (newSViv (r->i)));
       PUSHs (sv_2mortal (newSViv (r->b)));
@@ -541,8 +598,9 @@ PREINIT:
       char *val;
    CODE:
       val = guestfs_aug_get (g, path);
-      if (val == NULL)
+      if (val == NULL) {
         croak ("aug_get: %s", last_error);
+      }
       RETVAL = newSVpv (val, 0);
       free (val);
  OUTPUT:
@@ -554,8 +612,9 @@ aug_set (g, path, val)
       char *path;
       char *val;
  PPCODE:
-      if (guestfs_aug_set (g, path, val) == -1)
+      if (guestfs_aug_set (g, path, val) == -1) {
         croak ("aug_set: %s", last_error);
+      }
 
 void
 aug_insert (g, path, label, before)
@@ -564,8 +623,9 @@ aug_insert (g, path, label, before)
       char *label;
       int before;
  PPCODE:
-      if (guestfs_aug_insert (g, path, label, before) == -1)
+      if (guestfs_aug_insert (g, path, label, before) == -1) {
         croak ("aug_insert: %s", last_error);
+      }
 
 SV *
 aug_rm (g, path)
@@ -575,8 +635,9 @@ PREINIT:
       int nrnodes;
    CODE:
       nrnodes = guestfs_aug_rm (g, path);
-      if (nrnodes == -1)
+      if (nrnodes == -1) {
         croak ("aug_rm: %s", last_error);
+      }
       RETVAL = newSViv (nrnodes);
  OUTPUT:
       RETVAL
@@ -587,8 +648,9 @@ aug_mv (g, src, dest)
       char *src;
       char *dest;
  PPCODE:
-      if (guestfs_aug_mv (g, src, dest) == -1)
+      if (guestfs_aug_mv (g, src, dest) == -1) {
         croak ("aug_mv: %s", last_error);
+      }
 
 void
 aug_match (g, path)
@@ -599,8 +661,9 @@ PREINIT:
       int i, n;
  PPCODE:
       matches = guestfs_aug_match (g, path);
-      if (matches == NULL)
+      if (matches == NULL) {
         croak ("aug_match: %s", last_error);
+      }
       for (n = 0; matches[n] != NULL; ++n) /**/;
       EXTEND (SP, n);
       for (i = 0; i < n; ++i) {
@@ -613,15 +676,17 @@ void
 aug_save (g)
       guestfs_h *g;
  PPCODE:
-      if (guestfs_aug_save (g) == -1)
+      if (guestfs_aug_save (g) == -1) {
         croak ("aug_save: %s", last_error);
+      }
 
 void
 aug_load (g)
       guestfs_h *g;
  PPCODE:
-      if (guestfs_aug_load (g) == -1)
+      if (guestfs_aug_load (g) == -1) {
         croak ("aug_load: %s", last_error);
+      }
 
 void
 aug_ls (g, path)
@@ -632,8 +697,9 @@ PREINIT:
       int i, n;
  PPCODE:
       matches = guestfs_aug_ls (g, path);
-      if (matches == NULL)
+      if (matches == NULL) {
         croak ("aug_ls: %s", last_error);
+      }
       for (n = 0; matches[n] != NULL; ++n) /**/;
       EXTEND (SP, n);
       for (i = 0; i < n; ++i) {
@@ -647,40 +713,45 @@ rm (g, path)
       guestfs_h *g;
       char *path;
  PPCODE:
-      if (guestfs_rm (g, path) == -1)
+      if (guestfs_rm (g, path) == -1) {
         croak ("rm: %s", last_error);
+      }
 
 void
 rmdir (g, path)
       guestfs_h *g;
       char *path;
  PPCODE:
-      if (guestfs_rmdir (g, path) == -1)
+      if (guestfs_rmdir (g, path) == -1) {
         croak ("rmdir: %s", last_error);
+      }
 
 void
 rm_rf (g, path)
       guestfs_h *g;
       char *path;
  PPCODE:
-      if (guestfs_rm_rf (g, path) == -1)
+      if (guestfs_rm_rf (g, path) == -1) {
         croak ("rm_rf: %s", last_error);
+      }
 
 void
 mkdir (g, path)
       guestfs_h *g;
       char *path;
  PPCODE:
-      if (guestfs_mkdir (g, path) == -1)
+      if (guestfs_mkdir (g, path) == -1) {
         croak ("mkdir: %s", last_error);
+      }
 
 void
 mkdir_p (g, path)
       guestfs_h *g;
       char *path;
  PPCODE:
-      if (guestfs_mkdir_p (g, path) == -1)
+      if (guestfs_mkdir_p (g, path) == -1) {
         croak ("mkdir_p: %s", last_error);
+      }
 
 void
 chmod (g, mode, path)
@@ -688,8 +759,9 @@ chmod (g, mode, path)
       int mode;
       char *path;
  PPCODE:
-      if (guestfs_chmod (g, mode, path) == -1)
+      if (guestfs_chmod (g, mode, path) == -1) {
         croak ("chmod: %s", last_error);
+      }
 
 void
 chown (g, owner, group, path)
@@ -698,6 +770,164 @@ chown (g, owner, group, path)
       int group;
       char *path;
  PPCODE:
-      if (guestfs_chown (g, owner, group, path) == -1)
+      if (guestfs_chown (g, owner, group, path) == -1) {
         croak ("chown: %s", last_error);
+      }
+
+SV *
+exists (g, path)
+      guestfs_h *g;
+      char *path;
+PREINIT:
+      int existsflag;
+   CODE:
+      existsflag = guestfs_exists (g, path);
+      if (existsflag == -1) {
+        croak ("exists: %s", last_error);
+      }
+      RETVAL = newSViv (existsflag);
+ OUTPUT:
+      RETVAL
+
+SV *
+is_file (g, path)
+      guestfs_h *g;
+      char *path;
+PREINIT:
+      int fileflag;
+   CODE:
+      fileflag = guestfs_is_file (g, path);
+      if (fileflag == -1) {
+        croak ("is_file: %s", last_error);
+      }
+      RETVAL = newSViv (fileflag);
+ OUTPUT:
+      RETVAL
+
+SV *
+is_dir (g, path)
+      guestfs_h *g;
+      char *path;
+PREINIT:
+      int dirflag;
+   CODE:
+      dirflag = guestfs_is_dir (g, path);
+      if (dirflag == -1) {
+        croak ("is_dir: %s", last_error);
+      }
+      RETVAL = newSViv (dirflag);
+ OUTPUT:
+      RETVAL
+
+void
+pvcreate (g, device)
+      guestfs_h *g;
+      char *device;
+ PPCODE:
+      if (guestfs_pvcreate (g, device) == -1) {
+        croak ("pvcreate: %s", last_error);
+      }
+
+void
+vgcreate (g, volgroup, physvols)
+      guestfs_h *g;
+      char *volgroup;
+      char **physvols;
+ PPCODE:
+      if (guestfs_vgcreate (g, volgroup, physvols) == -1) {
+        free (physvols);
+        croak ("vgcreate: %s", last_error);
+      }
+        free (physvols);
+
+void
+lvcreate (g, logvol, volgroup, mbytes)
+      guestfs_h *g;
+      char *logvol;
+      char *volgroup;
+      int mbytes;
+ PPCODE:
+      if (guestfs_lvcreate (g, logvol, volgroup, mbytes) == -1) {
+        croak ("lvcreate: %s", last_error);
+      }
+
+void
+mkfs (g, fstype, device)
+      guestfs_h *g;
+      char *fstype;
+      char *device;
+ PPCODE:
+      if (guestfs_mkfs (g, fstype, device) == -1) {
+        croak ("mkfs: %s", last_error);
+      }
+
+void
+sfdisk (g, device, cyls, heads, sectors, lines)
+      guestfs_h *g;
+      char *device;
+      int cyls;
+      int heads;
+      int sectors;
+      char **lines;
+ PPCODE:
+      if (guestfs_sfdisk (g, device, cyls, heads, sectors, lines) == -1) {
+        free (lines);
+        croak ("sfdisk: %s", last_error);
+      }
+        free (lines);
+
+void
+write_file (g, path, content, size)
+      guestfs_h *g;
+      char *path;
+      char *content;
+      int size;
+ PPCODE:
+      if (guestfs_write_file (g, path, content, size) == -1) {
+        croak ("write_file: %s", last_error);
+      }
+
+void
+umount (g, pathordevice)
+      guestfs_h *g;
+      char *pathordevice;
+ PPCODE:
+      if (guestfs_umount (g, pathordevice) == -1) {
+        croak ("umount: %s", last_error);
+      }
+
+void
+mounts (g)
+      guestfs_h *g;
+PREINIT:
+      char **devices;
+      int i, n;
+ PPCODE:
+      devices = guestfs_mounts (g);
+      if (devices == NULL) {
+        croak ("mounts: %s", last_error);
+      }
+      for (n = 0; devices[n] != NULL; ++n) /**/;
+      EXTEND (SP, n);
+      for (i = 0; i < n; ++i) {
+        PUSHs (sv_2mortal (newSVpv (devices[i], 0)));
+        free (devices[i]);
+      }
+      free (devices);
+
+void
+umount_all (g)
+      guestfs_h *g;
+ PPCODE:
+      if (guestfs_umount_all (g) == -1) {
+        croak ("umount_all: %s", last_error);
+      }
+
+void
+lvm_remove_all (g)
+      guestfs_h *g;
+ PPCODE:
+      if (guestfs_lvm_remove_all (g) == -1) {
+        croak ("lvm_remove_all: %s", last_error);
+      }
 
diff --git a/perl/lib/Sys/Guestfs.pm b/perl/lib/Sys/Guestfs.pm
index 50f5d750..c708a29c 100644
--- a/perl/lib/Sys/Guestfs.pm
+++ b/perl/lib/Sys/Guestfs.pm
@@ -91,13 +91,13 @@ sub new {
   return $self;
 }
 
-=item $h->add_cdrom (filename);
+=item $h->add_cdrom ($filename);
 
 This function adds a virtual CD-ROM disk image to the guest.
 
 This is equivalent to the qemu parameter C<-cdrom filename>.
 
-=item $h->add_drive (filename);
+=item $h->add_drive ($filename);
 
 This function adds a virtual machine disk image C<filename> to the
 guest.  The first time you call this function, the disk appears as IDE
@@ -119,7 +119,7 @@ used by it.  After calling this, you have to call
 C<$h-E<gt>aug_init> again before you can use any other
 Augeas functions.
 
-=item ($nrnodes, $created) = $h->aug_defnode (name, expr, val);
+=item ($nrnodes, $created) = $h->aug_defnode ($name, $expr, $val);
 
 Defines a variable C<name> whose value is the result of
 evaluating C<expr>.
@@ -132,7 +132,7 @@ On success this returns a pair containing the
 number of nodes in the nodeset, and a boolean flag
 if a node was created.
 
-=item $nrnodes = $h->aug_defvar (name, expr);
+=item $nrnodes = $h->aug_defvar ($name, $expr);
 
 Defines an Augeas variable C<name> whose value is the result
 of evaluating C<expr>.  If C<expr> is NULL, then C<name> is
@@ -141,12 +141,12 @@ undefined.
 On success this returns the number of nodes in C<expr>, or
 C<0> if C<expr> evaluates to something which is not a nodeset.
 
-=item $val = $h->aug_get (path);
+=item $val = $h->aug_get ($path);
 
 Look up the value associated with C<path>.  If C<path>
 matches exactly one node, the C<value> is returned.
 
-=item $h->aug_init (root, flags);
+=item $h->aug_init ($root, $flags);
 
 Create a new Augeas handle for editing configuration files.
 If there was any previous Augeas handle associated with this
@@ -195,7 +195,7 @@ To close the handle, you can call C<$h-E<gt>aug_close>.
 
 To find out more about Augeas, see L<http://augeas.net/>.
 
-=item $h->aug_insert (path, label, before);
+=item $h->aug_insert ($path, $label, $before);
 
 Create a new sibling C<label> for C<path>, inserting it into
 the tree before or after C<path> (depending on the boolean
@@ -212,23 +212,23 @@ Load files into the tree.
 See C<aug_load> in the Augeas documentation for the full gory
 details.
 
-=item @matches = $h->aug_ls (path);
+=item @matches = $h->aug_ls ($path);
 
 This is just a shortcut for listing C<$h-E<gt>aug_match>
 C<path/*> and sorting the resulting nodes into alphabetical order.
 
-=item @matches = $h->aug_match (path);
+=item @matches = $h->aug_match ($path);
 
 Returns a list of paths which match the path expression C<path>.
 The returned paths are sufficiently qualified so that they match
 exactly one node in the current tree.
 
-=item $h->aug_mv (src, dest);
+=item $h->aug_mv ($src, $dest);
 
 Move the node C<src> to C<dest>.  C<src> must match exactly
 one node.  C<dest> is overwritten if it exists.
 
-=item $nrnodes = $h->aug_rm (path);
+=item $nrnodes = $h->aug_rm ($path);
 
 Remove C<path> and all of its children.
 
@@ -241,11 +241,11 @@ This writes all pending changes to disk.
 The flags which were passed to C<$h-E<gt>aug_init> affect exactly
 how files are saved.
 
-=item $h->aug_set (path, val);
+=item $h->aug_set ($path, $val);
 
 Set the value associated with C<path> to C<value>.
 
-=item $content = $h->cat (path);
+=item $content = $h->cat ($path);
 
 Return the contents of the file named C<path>.
 
@@ -258,12 +258,12 @@ Because of the message protocol, there is a transfer limit
 of somewhere between 2MB and 4MB.  To transfer large files you should use
 FTP.
 
-=item $h->chmod (mode, path);
+=item $h->chmod ($mode, $path);
 
 Change the mode (permissions) of C<path> to C<mode>.  Only
 numeric modes are supported.
 
-=item $h->chown (owner, group, path);
+=item $h->chown ($owner, $group, $path);
 
 Change the file owner to C<owner> and group to C<group>.
 
@@ -271,7 +271,7 @@ 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).
 
-=item $h->config (qemuparam, qemuvalue);
+=item $h->config ($qemuparam, $qemuvalue);
 
 This can be used to add arbitrary qemu command line parameters
 of the form C<-param value>.  Actually it's not quite arbitrary - we
@@ -282,6 +282,13 @@ The first character of C<param> string must be a C<-> (dash).
 
 C<value> can be NULL.
 
+=item $existsflag = $h->exists ($path);
+
+This returns C<true> if and only if there is a file, directory
+(or anything) with the given C<path> name.
+
+See also C<$h-E<gt>is_file>, C<$h-E<gt>is_dir>, C<$h-E<gt>stat>.
+
 =item $autosync = $h->get_autosync ();
 
 Get the autosync flag.
@@ -297,6 +304,22 @@ return the default path.
 
 This returns the verbose messages flag.
 
+=item $dirflag = $h->is_dir ($path);
+
+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<$h-E<gt>stat>.
+
+=item $fileflag = $h->is_file ($path);
+
+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<$h-E<gt>stat>.
+
 =item $h->kill_subprocess ();
 
 This kills the qemu subprocess.  You should never need to call this.
@@ -324,7 +347,7 @@ The full partition device names are returned, eg. C</dev/sda1>
 This does not return logical volumes.  For that you will need to
 call C<$h-E<gt>lvs>.
 
-=item $listing = $h->ll (directory);
+=item $listing = $h->ll ($directory);
 
 List the files in C<directory> (relative to the root directory,
 there is no cwd) in the format of 'ls -la'.
@@ -332,7 +355,7 @@ there is no cwd) in the format of 'ls -la'.
 This command is mostly useful for interactive sessions.  It
 is I<not> intended that you try to parse the output string.
 
-=item @listing = $h->ls (directory);
+=item @listing = $h->ls ($directory);
 
 List the files in C<directory> (relative to the root directory,
 there is no cwd).  The '.' and '..' entries are not returned, but
@@ -341,6 +364,19 @@ hidden files are shown.
 This command is mostly useful for interactive sessions.  Programs
 should probably use C<$h-E<gt>readdir> instead.
 
+=item $h->lvcreate ($logvol, $volgroup, $mbytes);
+
+This creates an LVM volume group called C<logvol>
+on the volume group C<volgroup>, with C<size> megabytes.
+
+=item $h->lvm_remove_all ();
+
+This command removes all LVM logical volumes, volume groups
+and physical volumes.
+
+B<This command is dangerous.  Without careful use you
+can easily destroy all your data>.
+
 =item @logvols = $h->lvs ();
 
 List all the logical volumes detected.  This is the equivalent
@@ -356,16 +392,22 @@ See also C<$h-E<gt>lvs_full>.
 List all the logical volumes detected.  This is the equivalent
 of the L<lvs(8)> command.  The "full" version includes all fields.
 
-=item $h->mkdir (path);
+=item $h->mkdir ($path);
 
 Create a directory named C<path>.
 
-=item $h->mkdir_p (path);
+=item $h->mkdir_p ($path);
 
 Create a directory named C<path>, creating any parent directories
 as necessary.  This is like the C<mkdir -p> shell command.
 
-=item $h->mount (device, mountpoint);
+=item $h->mkfs ($fstype, $device);
+
+This creates a filesystem on C<device> (usually a partition
+of LVM logical volume).  The filesystem type is C<fstype>, for
+example C<ext3>.
+
+=item $h->mount ($device, $mountpoint);
 
 Mount a guest disk at a position in the filesystem.  Block devices
 are named C</dev/sda>, C</dev/sdb> and so on, as they were added to
@@ -384,6 +426,19 @@ on the underlying device.
 The filesystem options C<sync> and C<noatime> are set with this
 call, in order to improve reliability.
 
+=item @devices = $h->mounts ();
+
+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.
+
+=item $h->pvcreate ($device);
+
+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>.
+
 =item @physvols = $h->pvs ();
 
 List all the physical volumes detected.  This is the equivalent
@@ -399,7 +454,7 @@ See also C<$h-E<gt>pvs_full>.
 List all the physical volumes detected.  This is the equivalent
 of the L<pvs(8)> command.  The "full" version includes all fields.
 
-=item @lines = $h->read_lines (path);
+=item @lines = $h->read_lines ($path);
 
 Return the contents of the file named C<path>.
 
@@ -411,27 +466,27 @@ Note that this function cannot correctly handle binary files
 as end of line).  For those you need to use the C<$h-E<gt>read_file>
 function which has a more complex interface.
 
-=item $h->rm (path);
+=item $h->rm ($path);
 
 Remove the single file C<path>.
 
-=item $h->rm_rf (path);
+=item $h->rm_rf ($path);
 
 Remove the file or directory C<path>, recursively removing the
 contents if its a directory.  This is like the C<rm -rf> shell
 command.
 
-=item $h->rmdir (path);
+=item $h->rmdir ($path);
 
 Remove the single directory C<path>.
 
-=item $h->set_autosync (autosync);
+=item $h->set_autosync ($autosync);
 
 If C<autosync> is true, this enables autosync.  Libguestfs will make a
 best effort attempt to run C<$h-E<gt>sync> when the handle is closed
 (also if the program exits without closing handles).
 
-=item $h->set_path (path);
+=item $h->set_path ($path);
 
 Set the path that libguestfs searches for kernel and initrd.img.
 
@@ -443,13 +498,38 @@ must make sure it remains valid for the lifetime of the handle.
 
 Setting C<path> to C<NULL> restores the default path.
 
-=item $h->set_verbose (verbose);
+=item $h->set_verbose ($verbose);
 
 If C<verbose> is true, this turns on verbose messages (to C<stderr>).
 
 Verbose messages are disabled unless the environment variable
 C<LIBGUESTFS_DEBUG> is defined and set to C<1>.
 
+=item $h->sfdisk ($device, $cyls, $heads, $sectors, \@lines);
+
+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).
+
+B<This command is dangerous.  Without careful use you
+can easily destroy all your data>.
+
 =item $h->sync ();
 
 This syncs the disk, so that any writes are flushed through to the
@@ -458,12 +538,29 @@ underlying disk image.
 You should always call this if you have modified a disk image, before
 closing the handle.
 
-=item $h->touch (path);
+=item $h->touch ($path);
 
 Touch acts like the L<touch(1)> command.  It can be used to
 update the timestamps on a file, or, if the file does not exist,
 to create a new zero-length file.
 
+=item $h->umount ($pathordevice);
+
+This unmounts the given filesystem.  The filesystem may be
+specified either by its mountpoint (path) or the device which
+contains the filesystem.
+
+=item $h->umount_all ();
+
+This unmounts all mounted filesystems.
+
+Some internal mounts are not unmounted by this call.
+
+=item $h->vgcreate ($volgroup, \@physvols);
+
+This creates an LVM volume group called C<volgroup>
+from the non-empty list of physical volumes C<physvols>.
+
 =item @volgroups = $h->vgs ();
 
 List all the volumes groups detected.  This is the equivalent
@@ -487,6 +584,20 @@ using L<qemu(1)>.
 You should call this after C<$h-E<gt>launch> to wait for the launch
 to complete.
 
+=item $h->write_file ($path, $content, $size);
+
+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).
+
+Because of the message protocol, there is a transfer limit 
+of somewhere between 2MB and 4MB.  To transfer large files you should use
+FTP.
+
 =cut
 
 1;