Libguestfs - Nov 2009 - [PATCH 0/3 VERSION 3 FOR DISCUSSION ONLY] FUSE support for libguestfs

This is the third version of the FUSE bindings for libguestfs.  Still,
read and write calls don't work, but you can now navigate through the
filesystem hierarchy efficiently.

Rich.

 .gitignore          |    3 +
 HACKING             |    3 +
 Makefile.am         |    5 +
 README              |    2 +
 TODO                |   37 +--
 bindtests           |   13 +
 bootstrap           |    2 +
 configure.ac        |    9 +
 daemon/Makefile.am  |    2 +
 daemon/dir.c        |   17 +
 daemon/file.c       |   17 +
 daemon/link.c       |   51 +++
 daemon/stat.c       |   68 ++++
 daemon/truncate.c   |   65 ++++
 daemon/utimens.c    |   81 ++++
 daemon/xattr.c      |  205 ++++++++++
 fuse/Makefile.am    |   62 +++
 fuse/dircache.c     |  400 +++++++++++++++++++
 fuse/dircache.h     |   43 ++
 fuse/fusexmp.c      |  385 +++++++++++++++++++
 fuse/fusexmp_fh.c   |  495 ++++++++++++++++++++++++
 fuse/guestmount.c   | 1063 +++++++++++++++++++++++++++++++++++++++++++++++++++
 fuse/guestmount.pod |  146 +++++++
 m4/.gitignore       |    2 +
 perl/typemap        |    1 +
 po/POTFILES.in      |    6 +
 src/MAX_PROC_NR     |    2 +-
 src/generator.ml    |  246 +++++++++++--
 28 files changed, 3377 insertions(+), 54 deletions(-)


-- 
Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones
libguestfs lets you edit virtual machines.  Supports shell scripting,
bindings from many languages.  http://et.redhat.com/~rjones/libguestfs/
See what it can do: http://et.redhat.com/~rjones/libguestfs/recipes.html

-- 
Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones
libguestfs lets you edit virtual machines.  Supports shell scripting,
bindings from many languages.  http://et.redhat.com/~rjones/libguestfs/
See what it can do: http://et.redhat.com/~rjones/libguestfs/recipes.html
-------------- next part --------------
>From 0115f29833ec01bea0dfd6ffecbd5caa002d5e68 Mon Sep 17 00:00:00 2001
From: Richard Jones <rjones at redhat.com>
Date: Fri, 30 Oct 2009 16:10:45 +0000
Subject: [PATCH 1/3] New API calls: truncate, truncate_size, mkdir_mode,
utimens, lchown.

truncate, truncate_size: Used to truncate files to a particular
size, or to zero bytes.

mkdir_mode: Like mkdir but allows you to also specify the
initial permissions for the new directory.

utimens: Set timestamp on a file with nanosecond accuracy.

lchown: Corresponding to lchown(2) syscall (we already have chown).

The implementation is complicated by the fact that we had to
add an Int64 parameter type to the generator.
---
 TODO               |    2 -
 bindtests          |   13 ++++
 daemon/Makefile.am |    2 +
 daemon/dir.c       |   17 +++++
 daemon/file.c      |   17 +++++
 daemon/truncate.c  |   65 +++++++++++++++++++
 daemon/utimens.c   |   81 ++++++++++++++++++++++++
 perl/typemap       |    1 +
 po/POTFILES.in     |    2 +
 src/MAX_PROC_NR    |    2 +-
 src/generator.ml   |  173 ++++++++++++++++++++++++++++++++++++++++++++--------
 11 files changed, 347 insertions(+), 28 deletions(-)
 create mode 100644 daemon/truncate.c
 create mode 100644 daemon/utimens.c

diff --git a/TODO b/TODO
index 2833d46..fc14cdc 100644
--- a/TODO
+++ b/TODO
@@ -145,9 +145,7 @@ Ideas for extra commands
   General glibc / core programs:
     chgrp
     dd (?)
-    utime / utimes / futimes / futimens / l..
     more mk*temp calls
-    trunc[ate??]
 
   ext2 properties:
     chattr
diff --git a/bindtests b/bindtests
index 6fbec99..e1772db 100644
--- a/bindtests
+++ b/bindtests
@@ -3,6 +3,7 @@ def
 []
 false
 0
+0
 123
 456
 abc
@@ -10,6 +11,7 @@ null
 []
 false
 0
+0
 123
 456
 
@@ -17,6 +19,7 @@ def
 []
 false
 0
+0
 123
 456
 
@@ -24,6 +27,7 @@ false
 []
 false
 0
+0
 123
 456
 abc
@@ -31,6 +35,7 @@ def
 ["1"]
 false
 0
+0
 123
 456
 abc
@@ -38,6 +43,7 @@ def
 ["1", "2"]
 false
 0
+0
 123
 456
 abc
@@ -45,6 +51,7 @@ def
 ["1"]
 true
 0
+0
 123
 456
 abc
@@ -52,6 +59,7 @@ def
 ["1"]
 false
 -1
+-1
 123
 456
 abc
@@ -59,6 +67,7 @@ def
 ["1"]
 false
 -2
+-2
 123
 456
 abc
@@ -66,6 +75,7 @@ def
 ["1"]
 false
 1
+1
 123
 456
 abc
@@ -73,6 +83,7 @@ def
 ["1"]
 false
 2
+2
 123
 456
 abc
@@ -80,6 +91,7 @@ def
 ["1"]
 false
 4095
+4095
 123
 456
 abc
@@ -87,6 +99,7 @@ def
 ["1"]
 false
 0
+0
 
 
 EOF
diff --git a/daemon/Makefile.am b/daemon/Makefile.am
index dce868a..db311ab 100644
--- a/daemon/Makefile.am
+++ b/daemon/Makefile.am
@@ -74,8 +74,10 @@ guestfsd_SOURCES = \
 	swap.c \
 	sync.c \
 	tar.c \
+	truncate.c \
 	umask.c \
 	upload.c \
+	utimens.c \
 	wc.c \
 	xattr.c \
 	zero.c \
diff --git a/daemon/dir.c b/daemon/dir.c
index 1ca6286..b603cfd 100644
--- a/daemon/dir.c
+++ b/daemon/dir.c
@@ -99,6 +99,23 @@ do_mkdir (const char *path)
   return 0;
 }
 
+int
+do_mkdir_mode (const char *path, int mode)
+{
+  int r;
+
+  CHROOT_IN;
+  r = mkdir (path, mode);
+  CHROOT_OUT;
+
+  if (r == -1) {
+    reply_with_perror ("mkdir_mode: %s", path);
+    return -1;
+  }
+
+  return 0;
+}
+
 static int
 recursive_mkdir (const char *path)
 {
diff --git a/daemon/file.c b/daemon/file.c
index 212aff2..7e2f062 100644
--- a/daemon/file.c
+++ b/daemon/file.c
@@ -232,6 +232,23 @@ do_chown (int owner, int group, const char *path)
 }
 
 int
+do_lchown (int owner, int group, const char *path)
+{
+  int r;
+
+  CHROOT_IN;
+  r = lchown (path, owner, group);
+  CHROOT_OUT;
+
+  if (r == -1) {
+    reply_with_perror ("lchown: %s: %d.%d", path, owner, group);
+    return -1;
+  }
+
+  return 0;
+}
+
+int
 do_exists (const char *path)
 {
   int r;
diff --git a/daemon/truncate.c b/daemon/truncate.c
new file mode 100644
index 0000000..c2da382
--- /dev/null
+++ b/daemon/truncate.c
@@ -0,0 +1,65 @@
+/* libguestfs - the guestfsd daemon
+ * Copyright (C) 2009 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "../src/guestfs_protocol.h"
+#include "daemon.h"
+#include "actions.h"
+
+int
+do_truncate_size (const char *path, int64_t size)
+{
+  int fd;
+  int r;
+
+  CHROOT_IN;
+  fd = open (path, O_WRONLY | O_NOCTTY);
+  CHROOT_OUT;
+
+  if (fd == -1) {
+    reply_with_perror ("open: %s", path);
+    return -1;
+  }
+
+  r = ftruncate (fd, (off_t) size);
+  if (r == -1) {
+    reply_with_perror ("ftruncate: %s", path);
+    close (fd);
+    return -1;
+  }
+
+  if (close (fd) == -1) {
+    reply_with_perror ("close: %s", path);
+    return -1;
+  }
+
+  return 0;
+}
+
+int
+do_truncate (const char *path)
+{
+  return do_truncate_size (path, 0);
+}
diff --git a/daemon/utimens.c b/daemon/utimens.c
new file mode 100644
index 0000000..2d0e3bf
--- /dev/null
+++ b/daemon/utimens.c
@@ -0,0 +1,81 @@
+/* libguestfs - the guestfsd daemon
+ * Copyright (C) 2009 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include "../src/guestfs_protocol.h"
+#include "daemon.h"
+#include "actions.h"
+
+int
+do_utimens (const char *path,
+            int64_t atsecs, int64_t atnsecs,
+            int64_t mtsecs, int64_t mtnsecs)
+{
+#ifndef HAVE_FUTIMENS
+  reply_with_error ("utimens: not supported in this appliance");
+  return -1;
+#else
+  int fd;
+  int r;
+
+  CHROOT_IN;
+  fd = open (path, O_WRONLY | O_NOCTTY);
+  CHROOT_OUT;
+
+  if (fd == -1) {
+    reply_with_perror ("open: %s", path);
+    return -1;
+  }
+
+  if (atnsecs == -1)
+    atnsecs = UTIME_NOW;
+  if (atnsecs == -2)
+    atnsecs = UTIME_OMIT;
+  if (mtnsecs == -1)
+    mtnsecs = UTIME_NOW;
+  if (mtnsecs == -2)
+    mtnsecs = UTIME_OMIT;
+
+  struct timespec times[2];
+  times[0].tv_sec = atsecs;
+  times[0].tv_nsec = atnsecs;
+  times[1].tv_sec = mtsecs;
+  times[1].tv_nsec = mtnsecs;
+
+  r = futimens (fd, times);
+  if (r == -1) {
+    reply_with_perror ("futimens: %s", path);
+    close (fd);
+    return -1;
+  }
+
+  if (close (fd) == -1) {
+    reply_with_perror ("close: %s", path);
+    return -1;
+  }
+
+  return 0;
+#endif /* HAVE_FUTIMENS */
+}
diff --git a/perl/typemap b/perl/typemap
index 97788d3..752ca0d 100644
--- a/perl/typemap
+++ b/perl/typemap
@@ -2,6 +2,7 @@ TYPEMAP
 char *		T_PV
 const char *	T_PV
 guestfs_h *	O_OBJECT_guestfs_h
+int64_t	  	T_IV
 
 INPUT
 O_OBJECT_guestfs_h
diff --git a/po/POTFILES.in b/po/POTFILES.in
index f6afb60..8c3c8f5 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -49,8 +49,10 @@ daemon/stubs.c
 daemon/swap.c
 daemon/sync.c
 daemon/tar.c
+daemon/truncate.c
 daemon/umask.c
 daemon/upload.c
+daemon/utimens.c
 daemon/wc.c
 daemon/xattr.c
 daemon/zero.c
diff --git a/src/MAX_PROC_NR b/src/MAX_PROC_NR
index ca55a6c..bb2ee19 100644
--- a/src/MAX_PROC_NR
+++ b/src/MAX_PROC_NR
@@ -1 +1 @@
-198
+203
diff --git a/src/generator.ml b/src/generator.ml
index b17ee65..939c142 100755
--- a/src/generator.ml
+++ b/src/generator.ml
@@ -142,6 +142,7 @@ and argt    | DeviceList of string(* list of Device names
(each cannot be NULL) *)
   | Bool of string	(* boolean *)
   | Int of string	(* int (smallish ints, signed, <= 31 bits) *)
+  | Int64 of string	(* any 64 bit int *)
     (* 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.
@@ -364,6 +365,7 @@ let test_all_args = [
   StringList "strlist";
   Bool "b";
   Int "integer";
+  Int64 "integer64";
   FileIn "filein";
   FileOut "fileout";
 ]
@@ -3715,6 +3717,72 @@ Usually the result is the name of the Linux VFS module
that
 is used to mount this device (probably determined automatically
 if you used the C<guestfs_mount> call).");
 
+  ("truncate", (RErr, [Pathname "path"]), 199, [],
+   [InitBasicFS, Always, TestOutputStruct (
+      [["write_file"; "/test"; "some stuff so size is
not zero"; "0"];
+       ["truncate"; "/test"];
+       ["stat"; "/test"]], [CompareWithInt
("size", 0)])],
+   "truncate a file to zero size",
+   "\
+This command truncates C<path> to a zero-length file.  The
+file must exist already.");
+
+  ("truncate_size", (RErr, [Pathname "path"; Int64
"size"]), 200, [],
+   [InitBasicFS, Always, TestOutputStruct (
+      [["touch"; "/test"];
+       ["truncate_size"; "/test"; "1000"];
+       ["stat"; "/test"]], [CompareWithInt
("size", 1000)])],
+   "truncate a file to a particular size",
+   "\
+This command truncates C<path> to size C<size> bytes.  The file
+must exist already.  If the file is smaller than C<size> then
+the file is extended to the required size with null bytes.");
+
+  ("utimens", (RErr, [Pathname "path"; Int64
"atsecs"; Int64 "atnsecs"; Int64 "mtsecs"; Int64
"mtnsecs"]), 201, [],
+   [InitBasicFS, Always, TestOutputStruct (
+      [["touch"; "/test"];
+       ["utimens"; "/test"; "12345";
"67890"; "9876"; "5432"];
+       ["stat"; "/test"]], [CompareWithInt
("mtime", 9876)])],
+   "set timestamp of a file with nanosecond precision",
+   "\
+This command sets the timestamps of a file with nanosecond
+precision.
+
+C<atsecs, atnsecs> are the last access time (atime) in secs and
+nanoseconds from the epoch.
+
+C<mtsecs, mtnsecs> are the last modification time (mtime) in
+secs and nanoseconds from the epoch.
+
+If the C<*nsecs> field contains the special value C<-1> then
+the corresponding timestamp is set to the current time.  (The
+C<*secs> field is ignored in this case).
+
+If the C<*nsecs> field contains the special value C<-2> then
+the corresponding timestamp is left unchanged.  (The
+C<*secs> field is ignored in this case).");
+
+  ("mkdir_mode", (RErr, [Pathname "path"; Int
"mode"]), 202, [],
+   [InitBasicFS, Always, TestOutputStruct (
+      [["mkdir_mode"; "/test"; "0o111"];
+       ["stat"; "/test"]], [CompareWithInt
("mode", 0o40111)])],
+   "create a directory with a particular mode",
+   "\
+This command creates a directory, setting the initial permissions
+of the directory to C<mode>.  See also C<guestfs_mkdir>.");
+
+  ("lchown", (RErr, [Int "owner"; Int "group";
Pathname "path"]), 203, [],
+   [], (* XXX *)
+   "change file owner and group",
+   "\
+Change the file owner to C<owner> and group to C<group>.
+This is like C<guestfs_chown> but if C<path> is a symlink then
+the link itself is changed, not the target.
+
+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).");
+
 ]
 
 let all_functions = non_daemon_functions @ daemon_functions
@@ -3955,6 +4023,7 @@ type callt    | CallOptString of string option
   | CallStringList of string list
   | CallInt of int
+  | CallInt64 of int64
   | CallBool of bool
 
 (* Used to memoize the result of pod2text. *)
@@ -4092,7 +4161,7 @@ let mapi f xs  
 let name_of_argt = function
   | Pathname n | Device n | Dev_or_Path n | String n | OptString n
-  | StringList n | DeviceList n | Bool n | Int n
+  | StringList n | DeviceList n | Bool n | Int n | Int64 n
   | FileIn n | FileOut n -> n
 
 let java_name_of_struct typ @@ -4508,11 +4577,13 @@ and generate_xdr ()        
pr "struct %s_args {\n" name;
            List.iter (
              function
-             | Pathname n | Device n | Dev_or_Path n | String n -> pr "
string %s<>;\n" n
+             | Pathname n | Device n | Dev_or_Path n | String n ->
+		 pr "  string %s<>;\n" n
              | OptString n -> pr "  str *%s;\n" n
              | StringList n | DeviceList n -> pr "  str
%s<>;\n" n
              | Bool n -> pr "  bool %s;\n" n
              | Int n -> pr "  int %s;\n" n
+             | Int64 n -> pr "  hyper %s;\n" n
              | FileIn _ | FileOut _ -> ()
            ) args;
            pr "};\n\n"
@@ -4701,6 +4772,8 @@ and generate_client_actions ()    pr "\
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
+#include <inttypes.h>
 
 #include \"guestfs.h\"
 #include \"guestfs-internal-actions.h\"
@@ -4803,6 +4876,8 @@ check_state (guestfs_h *g, const char *caller)
           pr "    fputs (%s ? \" true\" : \" false\",
stdout);\n" n
       | Int n ->			(* int *)
           pr "    printf (\" %%d\", %s);\n" n
+      | Int64 n ->
+          pr "    printf (\" %%\" PRIi64, %s);\n" n
     ) (snd style);
     pr "    putchar ('\\n');\n";
     pr "  }\n";
@@ -4892,6 +4967,8 @@ check_state (guestfs_h *g, const char *caller)
                  pr "  args.%s = %s;\n" n n
              | Int n ->
                  pr "  args.%s = %s;\n" n n
+             | Int64 n ->
+                 pr "  args.%s = %s;\n" n n
              | FileIn _ | FileOut _ -> ()
            ) args;
            pr "  serial = guestfs___send (g, GUESTFS_PROC_%s,\n"
@@ -5094,6 +5171,7 @@ and generate_daemon_actions ()               | StringList
n | DeviceList n -> pr "  char **%s;\n" n
              | Bool n -> pr "  int %s;\n" n
              | Int n -> pr "  int %s;\n" n
+             | Int64 n -> pr "  int64_t %s;\n" n
              | FileIn _ | FileOut _ -> ()
            ) args
       );
@@ -5145,6 +5223,7 @@ and generate_daemon_actions ()                   pr "
}\n";
              | Bool n -> pr "  %s = args.%s;\n" n n
              | Int n -> pr "  %s = args.%s;\n" n n
+             | Int64 n -> pr "  %s = args.%s;\n" n n
              | FileIn _ | FileOut _ -> ()
            ) args;
            pr "\n"
@@ -6047,6 +6126,7 @@ and generate_test_command_call ?(expect_error = false)
?test test_name cmd          | OptString n, arg ->
             pr "    const char *%s = \"%s\";\n" n (c_quote
arg);
         | Int _, _
+        | Int64 _, _
         | Bool _, _
         | FileIn _, _ | FileOut _, _ -> ()
         | StringList n, arg | DeviceList n, arg ->
@@ -6105,6 +6185,12 @@ and generate_test_command_call ?(expect_error = false)
?test test_name cmd                with Failure "int_of_string" ->
                 failwithf "%s: expecting an int, but got
'%s'" test_name arg in
             pr ", %d" i
+        | Int64 _, arg ->
+            let i +              try Int64.of_string arg
+              with Failure "int_of_string" ->
+                failwithf "%s: expecting an int64, but got
'%s'" test_name arg in
+            pr ", %Ld" i
         | Bool _, arg ->
             let b = bool_of_string arg in pr ", %d" (if b then 1 else
0)
       ) (List.combine (snd style) args);
@@ -6369,6 +6455,7 @@ and generate_fish_cmds ()          | StringList n |
DeviceList n -> pr "  char **%s;\n" n
         | Bool n -> pr "  int %s;\n" n
         | Int n -> pr "  int %s;\n" n
+        | Int64 n -> pr "  int64_t %s;\n" n
       ) (snd style);
 
       (* Check and convert parameters. *)
@@ -6405,6 +6492,8 @@ and generate_fish_cmds ()                pr "  %s =
is_true (argv[%d]) ? 1 : 0;\n" name i
           | Int name ->
               pr "  %s = atoi (argv[%d]);\n" name i
+          | Int64 name ->
+              pr "  %s = atoll (argv[%d]);\n" name i
       ) (snd style);
 
       (* Call C API function. *)
@@ -6419,7 +6508,7 @@ and generate_fish_cmds ()          function
         | Device name | String name
         | OptString name | FileIn name | FileOut name | Bool name
-        | Int name -> ()
+        | Int name | Int64 name -> ()
         | Pathname name | Dev_or_Path name ->
             pr "  free (%s);\n" name
         | StringList name | DeviceList name ->
@@ -6638,6 +6727,7 @@ and generate_fish_actions_pod ()          | StringList n |
DeviceList n -> pr " '%s ...'" n
         | Bool _ -> pr " true|false"
         | Int n -> pr " %s" n
+        | Int64 n -> pr " %s" n
         | FileIn n | FileOut n -> pr " (%s|-)" n
       ) (snd style);
       pr "\n";
@@ -6710,6 +6800,7 @@ and generate_prototype ?(extern = true) ?(static = false)
?(semicolon = true)
           pr "char *const *%s" n
       | Bool n -> next (); pr "int %s" n
       | Int n -> next (); pr "int %s" n
+      | Int64 n -> next (); pr "int64_t %s" n
       | FileIn n
       | FileOut n ->
           if not in_daemon then (next (); pr "const char *%s" n)
@@ -6992,6 +7083,8 @@ copy_table (char * const * argv)
             pr "  int %s = Bool_val (%sv);\n" n n
         | Int n ->
             pr "  int %s = Int_val (%sv);\n" n n
+        | Int64 n ->
+            pr "  int64_t %s = Int64_val (%sv);\n" n n
       ) (snd style);
       let error_code          match fst style with
@@ -7030,7 +7123,8 @@ copy_table (char * const * argv)
         function
         | StringList n | DeviceList n ->
             pr "  ocaml_guestfs_free_strings (%s);\n" n;
-        | Pathname _ | Device _ | Dev_or_Path _ | String _ | OptString _ | Bool
_ | Int _
+        | Pathname _ | Device _ | Dev_or_Path _ | String _ | OptString _
+	| Bool _ | Int _ | Int64 _
         | FileIn _ | FileOut _ -> ()
       ) (snd style);
 
@@ -7122,6 +7216,7 @@ and generate_ocaml_prototype ?(is_external = false) name
style      | StringList _ | DeviceList _ -> pr "string array ->
"
     | Bool _ -> pr "bool -> "
     | Int _ -> pr "int -> "
+    | Int64 _ -> pr "int64 -> "
   ) (snd style);
   (match fst style with
    | RErr -> pr "unit" (* all errors are turned into exceptions *)
@@ -7273,12 +7368,14 @@ DESTROY (g)
           | StringList n | DeviceList n -> pr "      char **%s;\n"
n
           | Bool n -> pr "      int %s;\n" n
           | Int n -> pr "      int %s;\n" n
+          | Int64 n -> pr "      int64_t %s;\n" n
       ) (snd style);
 
       let do_cleanups ()          List.iter (
           function
-          | Pathname _ | Device _ | Dev_or_Path _ | String _ | OptString _ |
Bool _ | Int _
+          | Pathname _ | Device _ | Dev_or_Path _ | String _ | OptString _
+	  | Bool _ | Int _ | Int64 _
           | FileIn _ | FileOut _ -> ()
           | StringList n | DeviceList n -> pr "      free (%s);\n"
n
         ) (snd style)
@@ -7650,7 +7747,7 @@ and generate_perl_prototype name style        comma :=
true;
       match arg with
       | Pathname n | Device n | Dev_or_Path n | String n
-      | OptString n | Bool n | Int n | FileIn n | FileOut n ->
+      | OptString n | Bool n | Int n | Int64 n | FileIn n | FileOut n ->
           pr "$%s" n
       | StringList n | DeviceList n ->
           pr "\\@%s" n
@@ -7917,6 +8014,7 @@ py_guestfs_close (PyObject *self, PyObject *args)
             pr "  char **%s;\n" n
         | Bool n -> pr "  int %s;\n" n
         | Int n -> pr "  int %s;\n" n
+        | Int64 n -> pr "  long long %s;\n" n
       ) (snd style);
 
       pr "\n";
@@ -7930,6 +8028,9 @@ py_guestfs_close (PyObject *self, PyObject *args)
         | StringList _ | DeviceList _ -> pr "O"
         | Bool _ -> pr "i" (* XXX Python has booleans? *)
         | Int _ -> pr "i"
+        | Int64 _ -> pr "L" (* XXX Whoever thought it was a good
idea to
+			     * emulate C's int/long/long long in Python?
+			     *)
       ) (snd style);
       pr ":guestfs_%s\",\n" name;
       pr "                         &py_g";
@@ -7940,6 +8041,7 @@ py_guestfs_close (PyObject *self, PyObject *args)
         | StringList n | DeviceList n -> pr ", &py_%s" n
         | Bool n -> pr ", &%s" n
         | Int n -> pr ", &%s" n
+        | Int64 n -> pr ", &%s" n
       ) (snd style);
 
       pr "))\n";
@@ -7949,7 +8051,7 @@ py_guestfs_close (PyObject *self, PyObject *args)
       List.iter (
         function
         | Pathname _ | Device _ | Dev_or_Path _ | String _
-        | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
+        | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ | Int64 _ ->
()
         | StringList n | DeviceList n ->
             pr "  %s = get_string_list (py_%s);\n" n n;
             pr "  if (!%s) return NULL;\n" n
@@ -7964,7 +8066,7 @@ py_guestfs_close (PyObject *self, PyObject *args)
       List.iter (
         function
         | Pathname _ | Device _ | Dev_or_Path _ | String _
-        | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
+        | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ | Int64 _ ->
()
         | StringList n | DeviceList n ->
             pr "  free (%s);\n" n
       ) (snd style);
@@ -8294,6 +8396,8 @@ static VALUE ruby_guestfs_close (VALUE gv)
             pr "  int %s = RTEST (%sv);\n" n n
         | Int n ->
             pr "  int %s = NUM2INT (%sv);\n" n n
+        | Int64 n ->
+            pr "  long long %s = NUM2LL (%sv);\n" n n
       ) (snd style);
       pr "\n";
 
@@ -8321,7 +8425,7 @@ static VALUE ruby_guestfs_close (VALUE gv)
       List.iter (
         function
         | Pathname _ | Device _ | Dev_or_Path _ | String _
-        | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ -> ()
+        | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ | Int64 _ ->
()
         | StringList n | DeviceList n ->
             pr "  free (%s);\n" n
       ) (snd style);
@@ -8644,6 +8748,8 @@ and generate_java_prototype ?(public=false)
?(privat=false) ?(native=false)
           pr "boolean %s" n
       | Int n ->
           pr "int %s" n
+      | Int64 n ->
+          pr "long %s" n
   ) (snd style);
 
   pr ")\n";
@@ -8763,6 +8869,8 @@ Java_com_redhat_et_libguestfs_GuestFS__1close
             pr ", jboolean j%s" n
         | Int n ->
             pr ", jint j%s" n
+        | Int64 n ->
+            pr ", jlong j%s" n
       ) (snd style);
       pr ")\n";
       pr "{\n";
@@ -8816,6 +8924,8 @@ Java_com_redhat_et_libguestfs_GuestFS__1close
         | Bool n
         | Int n ->
             pr "  int %s;\n" n
+        | Int64 n ->
+            pr "  int64_t %s;\n" n
       ) (snd style);
 
       let needs_i @@ -8857,7 +8967,8 @@
Java_com_redhat_et_libguestfs_GuestFS__1close
             pr "  }\n";
             pr "  %s[%s_len] = NULL;\n" n n;
         | Bool n
-        | Int n ->
+        | Int n
+        | Int64 n ->
             pr "  %s = j%s;\n" n n
       ) (snd style);
 
@@ -8886,7 +8997,8 @@ Java_com_redhat_et_libguestfs_GuestFS__1close
             pr "  }\n";
             pr "  free (%s);\n" n
         | Bool n
-        | Int n -> ()
+        | Int n
+	| Int64 n -> ()
       ) (snd style);
 
       (* Check for errors. *)
@@ -9148,7 +9260,7 @@ last_error h = do
           | Pathname n | Device n | Dev_or_Path n | String n -> pr
"withCString %s $ \\%s -> " n n
           | OptString n -> pr "maybeWith withCString %s $ \\%s ->
" n n
           | StringList n | DeviceList n -> pr "withMany withCString %s
$ \\%s -> withArray0 nullPtr %s $ \\%s -> " n n n n
-          | Bool _ | Int _ -> ()
+          | Bool _ | Int _ | Int64 _ -> ()
         ) (snd style);
         (* Convert integer arguments. *)
         let args @@ -9156,6 +9268,7 @@ last_error h = do
             function
             | Bool n -> sprintf "(fromBool %s)" n
             | Int n -> sprintf "(fromIntegral %s)" n
+            | Int64 n -> sprintf "(fromIntegral %s)" n
             | FileIn n | FileOut n
             | Pathname n | Device n | Dev_or_Path n | String n | OptString n |
StringList n | DeviceList n -> n
           ) (snd style) in
@@ -9212,6 +9325,7 @@ and generate_haskell_prototype ~handle ?(hs = false) style
| StringList _ | DeviceList _ -> if hs then pr "[String]" else pr
"Ptr CString"
        | Bool _ -> pr "%s" bool
        | Int _ -> pr "%s" int
+       | Int64 _ -> pr "%s" int
        | FileIn _ -> pr "%s" string
        | FileOut _ -> pr "%s" string
       );
@@ -9292,6 +9406,7 @@ print_strings (char *const *argv)
       | StringList n | DeviceList n -> pr "  print_strings
(%s);\n" n
       | Bool n -> pr "  printf (\"%%s\\n\", %s ?
\"true\" : \"false\");\n" n
       | Int n -> pr "  printf (\"%%d\\n\", %s);\n" n
+      | Int64 n -> pr "  printf (\"%%\" PRIi64
\"\\n\", %s);\n" n
     ) (snd style);
     pr "  /* Java changes stdout line buffering so we need this:
*/\n";
     pr "  fflush (stdout);\n";
@@ -9407,6 +9522,8 @@ let ()              "[|" ^ String.concat
";" (List.map (sprintf "\"%s\"") xs) ^
"|]"
         | CallInt i when i >= 0 -> string_of_int i
         | CallInt i (* when i < 0 *) -> "(" ^ string_of_int i ^
")"
+        | CallInt64 i when i >= 0L -> Int64.to_string i ^ "L"
+        | CallInt64 i (* when i < 0L *) -> "(" ^
Int64.to_string i ^ "L)"
         | CallBool b -> string_of_bool b
       ) args
     )
@@ -9440,6 +9557,7 @@ my $g = Sys::Guestfs->new ();
         | CallStringList xs ->
             "[" ^ String.concat "," (List.map (sprintf
"\"%s\"") xs) ^ "]"
         | CallInt i -> string_of_int i
+        | CallInt64 i -> Int64.to_string i
         | CallBool b -> if b then "1" else "0"
       ) args
     )
@@ -9470,6 +9588,7 @@ g = guestfs.GuestFS ()
         | CallStringList xs ->
             "[" ^ String.concat "," (List.map (sprintf
"\"%s\"") xs) ^ "]"
         | CallInt i -> string_of_int i
+        | CallInt64 i -> Int64.to_string i
         | CallBool b -> if b then "1" else "0"
       ) args
     )
@@ -9500,6 +9619,7 @@ g = Guestfs::create()
         | CallStringList xs ->
             "[" ^ String.concat "," (List.map (sprintf
"\"%s\"") xs) ^ "]"
         | CallInt i -> string_of_int i
+        | CallInt64 i -> Int64.to_string i
         | CallBool b -> string_of_bool b
       ) args
     )
@@ -9535,6 +9655,7 @@ public class Bindtests {
             "new String[]{" ^
               String.concat "," (List.map (sprintf
"\"%s\"") xs) ^ "}"
         | CallInt i -> string_of_int i
+        | CallInt64 i -> Int64.to_string i
         | CallBool b -> string_of_bool b
       ) args
     )
@@ -9577,6 +9698,8 @@ main = do
             "[" ^ String.concat "," (List.map (sprintf
"\"%s\"") xs) ^ "]"
         | CallInt i when i < 0 -> "(" ^ string_of_int i ^
")"
         | CallInt i -> string_of_int i
+        | CallInt64 i when i < 0L -> "(" ^ Int64.to_string i ^
")"
+        | CallInt64 i -> Int64.to_string i
         | CallBool true -> "True"
         | CallBool false -> "False"
       ) args
@@ -9595,43 +9718,43 @@ main = do
 and generate_lang_bindtests call    call "test0" [CallString
"abc"; CallOptString (Some "def");
                 CallStringList []; CallBool false;
-                CallInt 0; CallString "123"; CallString
"456"];
+                CallInt 0; CallInt64 0L; CallString "123"; CallString
"456"];
   call "test0" [CallString "abc"; CallOptString None;
                 CallStringList []; CallBool false;
-                CallInt 0; CallString "123"; CallString
"456"];
+                CallInt 0; CallInt64 0L; CallString "123"; CallString
"456"];
   call "test0" [CallString ""; CallOptString (Some
"def");
                 CallStringList []; CallBool false;
-                CallInt 0; CallString "123"; CallString
"456"];
+                CallInt 0; CallInt64 0L; CallString "123"; CallString
"456"];
   call "test0" [CallString ""; CallOptString (Some
"");
                 CallStringList []; CallBool false;
-                CallInt 0; CallString "123"; CallString
"456"];
+                CallInt 0; CallInt64 0L; CallString "123"; CallString
"456"];
   call "test0" [CallString "abc"; CallOptString (Some
"def");
                 CallStringList ["1"]; CallBool false;
-                CallInt 0; CallString "123"; CallString
"456"];
+                CallInt 0; CallInt64 0L; CallString "123"; CallString
"456"];
   call "test0" [CallString "abc"; CallOptString (Some
"def");
                 CallStringList ["1"; "2"]; CallBool false;
-                CallInt 0; CallString "123"; CallString
"456"];
+                CallInt 0; CallInt64 0L; CallString "123"; CallString
"456"];
   call "test0" [CallString "abc"; CallOptString (Some
"def");
                 CallStringList ["1"]; CallBool true;
-                CallInt 0; CallString "123"; CallString
"456"];
+                CallInt 0; CallInt64 0L; CallString "123"; CallString
"456"];
   call "test0" [CallString "abc"; CallOptString (Some
"def");
                 CallStringList ["1"]; CallBool false;
-                CallInt (-1); CallString "123"; CallString
"456"];
+                CallInt (-1); CallInt64 (-1L); CallString "123";
CallString "456"];
   call "test0" [CallString "abc"; CallOptString (Some
"def");
                 CallStringList ["1"]; CallBool false;
-                CallInt (-2); CallString "123"; CallString
"456"];
+                CallInt (-2); CallInt64 (-2L); CallString "123";
CallString "456"];
   call "test0" [CallString "abc"; CallOptString (Some
"def");
                 CallStringList ["1"]; CallBool false;
-                CallInt 1; CallString "123"; CallString
"456"];
+                CallInt 1; CallInt64 1L; CallString "123"; CallString
"456"];
   call "test0" [CallString "abc"; CallOptString (Some
"def");
                 CallStringList ["1"]; CallBool false;
-                CallInt 2; CallString "123"; CallString
"456"];
+                CallInt 2; CallInt64 2L; CallString "123"; CallString
"456"];
   call "test0" [CallString "abc"; CallOptString (Some
"def");
                 CallStringList ["1"]; CallBool false;
-                CallInt 4095; CallString "123"; CallString
"456"];
+                CallInt 4095; CallInt64 4095L; CallString "123";
CallString "456"];
   call "test0" [CallString "abc"; CallOptString (Some
"def");
                 CallStringList ["1"]; CallBool false;
-                CallInt 0; CallString ""; CallString ""]
+                CallInt 0; CallInt64 0L; CallString ""; CallString
""]
 
 (* XXX Add here tests of the return and error functions. *)
 
-- 
1.6.5.rc2

These are in a separate patch because they are used to optimize
directory reads.  It's not likely the API calls would be useful to end
users, but could be useful for people implementing things like file
browsers, and consequently for FUSE support.

Rich.

-- 
Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones
virt-top is 'top' for virtual machines.  Tiny program with many
powerful monitoring features, net stats, disk stats, logging, etc.
http://et.redhat.com/~rjones/virt-top
-------------- next part --------------
>From ff0855889fe655605ba2a225724ff742bc062479 Mon Sep 17 00:00:00 2001
From: Richard Jones <rjones at redhat.com>
Date: Sat, 31 Oct 2009 13:41:18 +0000
Subject: [PATCH 2/3] New API calls: lstatlist, lxattrlist, readlinklist.

These three functions are very specifically designed for FUSE
support, so we can list directories efficiently.  Instead of
making lots of lstat, lgetxattr and readlink calls, we can make just
three calls per directory to grab all the attributes (which we
then cache briefly).
---
 daemon/link.c    |   51 +++++++++++++
 daemon/stat.c    |   68 ++++++++++++++++++
 daemon/xattr.c   |  205 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/MAX_PROC_NR  |    2 +-
 src/generator.ml |   73 +++++++++++++++++++
 5 files changed, 398 insertions(+), 1 deletions(-)

diff --git a/daemon/link.c b/daemon/link.c
index a77c2e8..5ea0d39 100644
--- a/daemon/link.c
+++ b/daemon/link.c
@@ -21,6 +21,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <fcntl.h>
 #include <unistd.h>
 #include <limits.h>
 
@@ -51,6 +52,56 @@ do_readlink (const char *path)
   return ret;			/* caller frees */
 }
 
+char **
+do_readlinklist (const char *path, char *const *names)
+{
+  int fd_cwd;
+  size_t i;
+  ssize_t r;
+  char link[PATH_MAX];
+  const char *str;
+  char **ret = NULL;
+  int size = 0, alloc = 0;
+
+  CHROOT_IN;
+  fd_cwd = open (path, O_RDONLY | O_DIRECTORY);
+  CHROOT_OUT;
+
+  if (fd_cwd == -1) {
+    reply_with_perror ("readlinklist: %s", path);
+    return NULL;
+  }
+
+  for (i = 0; names[i] != NULL; ++i) {
+    r = readlinkat (fd_cwd, names[i], link, sizeof link);
+    if (r >= PATH_MAX) {
+      reply_with_perror ("readlinkat: returned link is too long");
+      free_strings (ret);
+      close (fd_cwd);
+      return NULL;
+    }
+    /* Because of the way this function is intended to be used,
+     * we actually expect to see errors here, and they are not fatal.
+     */
+    if (r >= 0) {
+      link[r] = '\0';
+      str = link;
+    } else
+      str = "";
+    if (add_string (&ret, &size, &alloc, str) == -1) {
+      close (fd_cwd);
+      return NULL;
+    }
+  }
+
+  close (fd_cwd);
+
+  if (add_string (&ret, &size, &alloc, NULL) == -1)
+    return NULL;
+
+  return ret;
+}
+
 static int
 _link (const char *flag, int symbolic, const char *target, const char
*linkname)
 {
diff --git a/daemon/stat.c b/daemon/stat.c
index 4ff2711..2441c9f 100644
--- a/daemon/stat.c
+++ b/daemon/stat.c
@@ -24,6 +24,7 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/statvfs.h>
+#include <fcntl.h>
 #include <unistd.h>
 
 #include "../src/guestfs_protocol.h"
@@ -108,6 +109,73 @@ do_lstat (const char *path)
   return ret;
 }
 
+guestfs_int_stat_list *
+do_lstatlist (const char *path, char *const *names)
+{
+  int path_fd;
+  guestfs_int_stat_list *ret;
+  size_t i, nr_names;
+
+  nr_names = count_strings (names);
+
+  ret = malloc (sizeof *ret);
+  if (!ret) {
+    reply_with_perror ("malloc");
+    return NULL;
+  }
+  ret->guestfs_int_stat_list_len = nr_names;
+  ret->guestfs_int_stat_list_val = calloc (nr_names, sizeof
(guestfs_int_stat));
+  if (ret->guestfs_int_stat_list_val == NULL) {
+    reply_with_perror ("malloc");
+    free (ret);
+    return NULL;
+  }
+
+  CHROOT_IN;
+  path_fd = open (path, O_RDONLY | O_DIRECTORY);
+  CHROOT_OUT;
+
+  if (path_fd == -1) {
+    reply_with_perror ("lstatlist: %s", path);
+    free (ret->guestfs_int_stat_list_val);
+    free (ret);
+    return NULL;
+  }
+
+  for (i = 0; names[i] != NULL; ++i) {
+    int r;
+    struct stat statbuf;
+
+    r = fstatat (path_fd, names[i], &statbuf, AT_SYMLINK_NOFOLLOW);
+    if (r == -1)
+      ret->guestfs_int_stat_list_val[i].ino = -1;
+    else {
+      ret->guestfs_int_stat_list_val[i].dev = statbuf.st_dev;
+      ret->guestfs_int_stat_list_val[i].ino = statbuf.st_ino;
+      ret->guestfs_int_stat_list_val[i].mode = statbuf.st_mode;
+      ret->guestfs_int_stat_list_val[i].nlink = statbuf.st_nlink;
+      ret->guestfs_int_stat_list_val[i].uid = statbuf.st_uid;
+      ret->guestfs_int_stat_list_val[i].gid = statbuf.st_gid;
+      ret->guestfs_int_stat_list_val[i].rdev = statbuf.st_rdev;
+      ret->guestfs_int_stat_list_val[i].size = statbuf.st_size;
+      ret->guestfs_int_stat_list_val[i].blksize = statbuf.st_blksize;
+      ret->guestfs_int_stat_list_val[i].blocks = statbuf.st_blocks;
+      ret->guestfs_int_stat_list_val[i].atime = statbuf.st_atime;
+      ret->guestfs_int_stat_list_val[i].mtime = statbuf.st_mtime;
+      ret->guestfs_int_stat_list_val[i].ctime = statbuf.st_ctime;
+    }
+  }
+
+  if (close (path_fd) == -1) {
+    reply_with_perror ("close: %s", path);
+    free (ret->guestfs_int_stat_list_val);
+    free (ret);
+    return NULL;
+  }
+
+  return ret;
+}
+
 guestfs_int_statvfs *
 do_statvfs (const char *path)
 {
diff --git a/daemon/xattr.c b/daemon/xattr.c
index 1531070..fe1d2b6 100644
--- a/daemon/xattr.c
+++ b/daemon/xattr.c
@@ -243,6 +243,204 @@ _removexattr (const char *xattr, const char *path,
   return 0;
 }
 
+guestfs_int_xattr_list *
+do_lxattrlist (const char *path, char *const *names)
+{
+#if defined(HAVE_LLISTXATTR) && defined(HAVE_LGETXATTR)
+  /* XXX This would be easier if the kernel had lgetxattrat.  In the
+   * meantime we use this buffer to store the whole path name.
+   */
+  char pathname[PATH_MAX];
+  size_t path_len = strlen (path);
+  guestfs_int_xattr_list *ret = NULL;
+  int i, j;
+  size_t k, m, nr_attrs;
+  ssize_t len, vlen;
+  char *buf = NULL;
+
+  if (path_len >= PATH_MAX) {
+    reply_with_perror ("lxattrlist: path longer than PATH_MAX");
+    goto error;
+  }
+
+  strcpy (pathname, path);
+
+  ret = malloc (sizeof (*ret));
+  if (ret == NULL) {
+    reply_with_perror ("malloc");
+    goto error;
+  }
+
+  ret->guestfs_int_xattr_list_len = 0;
+  ret->guestfs_int_xattr_list_val = NULL;
+
+  for (k = 0; names[k] != NULL; ++k) {
+    /* Be careful in here about which errors cause the whole call
+     * to abort, and which errors allow us to continue processing
+     * the call, recording a special "error attribute" in the
+     * outgoing struct list.
+     */
+    if (path_len + strlen (names[k]) + 2 > PATH_MAX) {
+      reply_with_perror ("lxattrlist: path and name longer than
PATH_MAX");
+      goto error;
+    }
+    pathname[path_len] = '/';
+    strcpy (&pathname[path_len+1], names[k]);
+
+    /* Reserve space for the special attribute. */
+    void *newptr +      realloc (ret->guestfs_int_xattr_list_val,
+               (ret->guestfs_int_xattr_list_len+1)*sizeof
(guestfs_int_xattr));
+    if (newptr == NULL) {
+      reply_with_perror ("realloc");
+      goto error;
+    }
+    ret->guestfs_int_xattr_list_val = newptr;
+    ret->guestfs_int_xattr_list_len++;
+
+    guestfs_int_xattr *entry +     
&ret->guestfs_int_xattr_list_val[ret->guestfs_int_xattr_list_len-1];
+    entry->attrname = NULL;
+    entry->attrval.attrval_len = 0;
+    entry->attrval.attrval_val = NULL;
+
+    entry->attrname = strdup ("");
+    if (entry->attrname == NULL) {
+      reply_with_perror ("strdup");
+      goto error;
+    }
+
+    CHROOT_IN;
+    len = llistxattr (pathname, NULL, 0);
+    CHROOT_OUT;
+    if (len == -1)
+      continue; /* not fatal */
+
+    buf = malloc (len);
+    if (buf == NULL) {
+      reply_with_perror ("malloc");
+      goto error;
+    }
+
+    CHROOT_IN;
+    len = llistxattr (pathname, buf, len);
+    CHROOT_OUT;
+    if (len == -1)
+      continue; /* not fatal */
+
+    /* What we get from the kernel is a string "foo\0bar\0baz" of
length
+     * len.  First count the strings.
+     */
+    nr_attrs = 0;
+    for (i = 0; i < len; i += strlen (&buf[i]) + 1)
+      nr_attrs++;
+
+    newptr +      realloc (ret->guestfs_int_xattr_list_val,
+               (ret->guestfs_int_xattr_list_len+nr_attrs) *
+               sizeof (guestfs_int_xattr));
+    if (newptr == NULL) {
+      reply_with_perror ("realloc");
+      goto error;
+    }
+    ret->guestfs_int_xattr_list_val = newptr;
+    ret->guestfs_int_xattr_list_len += nr_attrs;
+
+    /* entry[0] is the special attribute,
+     * entry[1..nr_attrs] are the attributes.
+     */
+    entry =
&ret->guestfs_int_xattr_list_val[ret->guestfs_int_xattr_list_len-nr_attrs-1];
+    for (m = 1; m <= nr_attrs; ++m) {
+      entry[m].attrname = NULL;
+      entry[m].attrval.attrval_len = 0;
+      entry[m].attrval.attrval_val = NULL;
+    }
+
+    for (i = 0, j = 0; i < len; i += strlen (&buf[i]) + 1, ++j) {
+      CHROOT_IN;
+      vlen = lgetxattr (pathname, &buf[i], NULL, 0);
+      CHROOT_OUT;
+      if (vlen == -1) {
+        reply_with_perror ("getxattr");
+        goto error;
+      }
+
+      entry[j+1].attrname = strdup (&buf[i]);
+      entry[j+1].attrval.attrval_val = malloc (vlen);
+      entry[j+1].attrval.attrval_len = vlen;
+
+      if (entry[j+1].attrname == NULL ||
+          entry[j+1].attrval.attrval_val == NULL) {
+        reply_with_perror ("malloc");
+        goto error;
+      }
+
+      CHROOT_IN;
+      vlen = getxattr (pathname, &buf[i],
+                       entry[j+1].attrval.attrval_val, vlen);
+      CHROOT_OUT;
+      if (vlen == -1) {
+        reply_with_perror ("getxattr");
+        goto error;
+      }
+    }
+
+    free (buf); buf = NULL;
+
+    char num[16];
+    snprintf (num, sizeof num, "%zu", nr_attrs);
+    entry[0].attrval.attrval_len = strlen (num) + 1;
+    entry[0].attrval.attrval_val = strdup (num);
+
+    if (entry[0].attrval.attrval_val == NULL) {
+      reply_with_perror ("strdup");
+      goto error;
+    }
+  }
+
+  /* If verbose, debug what we're about to send back. */
+  if (verbose) {
+    fprintf (stderr, "lxattrlist: returning: [\n");
+    for (k = 0; k < ret->guestfs_int_xattr_list_len; ++k) {
+      const guestfs_int_xattr *entry =
&ret->guestfs_int_xattr_list_val[k];
+      if (strcmp (entry[0].attrname, "") != 0) {
+        fprintf (stderr, "ERROR: expecting empty attrname at k =
%zu\n", k);
+        break;
+      }
+      fprintf (stderr, "  %zu: special attrval = %s\n",
+               k, entry[0].attrval.attrval_val);
+      for (i = 1; k+i < ret->guestfs_int_xattr_list_len; ++i) {
+        if (strcmp (entry[i].attrname, "") == 0)
+          break;
+        fprintf (stderr, "    name %s, value length %d\n",
+                 entry[i].attrname, entry[i].attrval.attrval_len);
+      }
+      k += i-1;
+    }
+    fprintf (stderr, "]\n");
+  }
+
+  return ret;
+
+ error:
+  free (buf);
+  if (ret) {
+    if (ret->guestfs_int_xattr_list_val) {
+      for (k = 0; k < ret->guestfs_int_xattr_list_len; ++k) {
+        free (ret->guestfs_int_xattr_list_val[k].attrname);
+        free (ret->guestfs_int_xattr_list_val[k].attrval.attrval_val);
+      }
+      free (ret->guestfs_int_xattr_list_val);
+    }
+    free (ret);
+  }
+  return NULL;
+#else
+  reply_with_error ("lxattrlist: no support for llistxattr and
lgetxattr");
+  return NULL;
+#endif
+}
+
 #else /* no xattr.h */
 
 guestfs_int_xattr_list *
@@ -287,4 +485,11 @@ do_lremovexattr (const char *xattr, const char *path)
   return -1;
 }
 
+guestfs_int_xattr_list *
+do_lxattrlist (const char *path, char *const *names)
+{
+  reply_with_error ("lxattrlist: no support for xattrs");
+  return NULL;
+}
+
 #endif /* no xattr.h */
diff --git a/src/MAX_PROC_NR b/src/MAX_PROC_NR
index bb2ee19..b35cfaf 100644
--- a/src/MAX_PROC_NR
+++ b/src/MAX_PROC_NR
@@ -1 +1 @@
-203
+206
diff --git a/src/generator.ml b/src/generator.ml
index 939c142..dd281dd 100755
--- a/src/generator.ml
+++ b/src/generator.ml
@@ -3783,6 +3783,79 @@ 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).");
 
+  ("lstatlist", (RStructList ("statbufs",
"stat"), [Pathname "path"; StringList "names"]),
204, [],
+   [], (* XXX *)
+   "lstat on multiple files",
+   "\
+This call allows you to perform the C<guestfs_lstat> operation
+on multiple files, where all files are in the directory C<path>.
+C<names> is the list of files from this directory.
+
+On return you get a list of stat structs, with a one-to-one
+correspondence to the C<names> list.  If any name did not exist
+or could not be lstat'd, then the C<ino> field of that structure
+is set to C<-1>.
+
+This call is intended for programs that want to efficiently
+list a directory contents without making many round-trips.
+See also C<guestfs_lxattrlist> for a similarly efficient call
+for getting extended attributes.  Very long directory listings
+might cause the protocol message size to be exceeded, causing
+this call to fail.  The caller must split up such requests
+into smaller groups of names.");
+
+  ("lxattrlist", (RStructList ("xattrs",
"xattr"), [Pathname "path"; StringList "names"]),
205, [],
+   [], (* XXX *)
+   "lgetxattr on multiple files",
+   "\
+This call allows you to get the extended attributes
+of multiple files, where all files are in the directory C<path>.
+C<names> is the list of files from this directory.
+
+On return you get a flat list of xattr structs which must be
+interpreted sequentially.  The first xattr struct always has a zero-length
+C<attrname>.  C<attrval> in this struct is zero-length
+to indicate there was an error doing C<lgetxattr> for this
+file, I<or> is a C string which is a decimal number
+(the number of following attributes for this file, which could
+be C<\"0\">).  Then after the first xattr struct are the
+zero or more attributes for the first named file.
+This repeats for the second and subsequent files.
+
+This call is intended for programs that want to efficiently
+list a directory contents without making many round-trips.
+See also C<guestfs_lstatlist> for a similarly efficient call
+for getting standard stats.  Very long directory listings
+might cause the protocol message size to be exceeded, causing
+this call to fail.  The caller must split up such requests
+into smaller groups of names.");
+
+  ("readlinklist", (RStringList "links", [Pathname
"path"; StringList "names"]), 206, [],
+   [], (* XXX *)
+   "readlink on multiple files",
+   "\
+This call allows you to do a C<readlink> operation
+on multiple files, where all files are in the directory C<path>.
+C<names> is the list of files from this directory.
+
+On return you get a list of strings, with a one-to-one
+correspondence to the C<names> list.  Each string is the
+value of the symbol link.
+
+If the C<readlink(2)> operation fails on any name, then
+the corresponding result string is the empty string C<\"\">.
+However the whole operation is completed even if there
+were C<readlink(2)> errors, and so you can call this
+function with names where you don't know if they are
+symbolic links already (albeit slightly less efficient).
+
+This call is intended for programs that want to efficiently
+list a directory contents without making many round-trips.
+Very long directory listings might cause the protocol
+message size to be exceeded, causing
+this call to fail.  The caller must split up such requests
+into smaller groups of names.");
+
 ]
 
 let all_functions = non_daemon_functions @ daemon_functions
-- 
1.6.5.rc2

Note if you're trying this that the read(2) system call has been
rigged to return random crap, just so we could test the behaviour of
reads under FUSE.  read and write of files is not implemented yet.

Rich.

-- 
Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones
virt-p2v converts physical machines to virtual machines.  Boot with a
live CD or over the network (PXE) and turn machines into Xen guests.
http://et.redhat.com/~rjones/virt-p2v
-------------- next part --------------
>From 07d04310f3c9deff8db648efd852a72fe0858f7e Mon Sep 17 00:00:00 2001
From: Richard Jones <rjones at redhat.com>
Date: Fri, 30 Oct 2009 16:13:13 +0000
Subject: [PATCH 3/3] FUSE filesystem support.

This implements FUSE filesystem support so that any libguestfs-
accessible disk image can be mounted as a local filesystem.

The API needs more test coverage, particularly lesser-used system
calls.

The big unresolved issue is UID/GID mapping between guest filesystem
IDs and the host.  It's not easy to automate this because you need
extra details about the guest itself in order to get to its
UID->username map (eg. /etc/passwd from the guest).
---
 .gitignore          |    3 +
 HACKING             |    3 +
 Makefile.am         |    5 +
 README              |    2 +
 TODO                |   35 +--
 bootstrap           |    2 +
 configure.ac        |    9 +
 daemon/xattr.c      |    4 +-
 fuse/Makefile.am    |   62 +++
 fuse/dircache.c     |  400 +++++++++++++++++++
 fuse/dircache.h     |   43 ++
 fuse/fusexmp.c      |  385 +++++++++++++++++++
 fuse/fusexmp_fh.c   |  495 ++++++++++++++++++++++++
 fuse/guestmount.c   | 1063 +++++++++++++++++++++++++++++++++++++++++++++++++++
 fuse/guestmount.pod |  146 +++++++
 m4/.gitignore       |    2 +
 po/POTFILES.in      |    4 +
 17 files changed, 2635 insertions(+), 28 deletions(-)
 create mode 100644 fuse/Makefile.am
 create mode 100644 fuse/dircache.c
 create mode 100644 fuse/dircache.h
 create mode 100644 fuse/fusexmp.c
 create mode 100644 fuse/fusexmp_fh.c
 create mode 100644 fuse/guestmount.c
 create mode 100644 fuse/guestmount.pod

diff --git a/.gitignore b/.gitignore
index ffa9764..fbe7998 100644
--- a/.gitignore
+++ b/.gitignore
@@ -54,6 +54,8 @@ fish/completion.c
 fish/guestfish
 fish/rc_protocol.c
 fish/rc_protocol.h
+fuse/guestmount
+fuse/guestmount.1
 guestfish.1
 guestfish-actions.pod
 guestfs.3
@@ -72,6 +74,7 @@ hivex/hivexget
 hivex/hivexml
 html/guestfish.1.html
 html/guestfs.3.html
+html/guestmount.1.html
 html/hivex.3.html
 html/hivexget.1.html
 html/hivexml.1.html
diff --git a/HACKING b/HACKING
index cc5b1c2..5752ec3 100644
--- a/HACKING
+++ b/HACKING
@@ -83,6 +83,9 @@ examples/
 fish/
         Guestfish (the command-line program / shell)
 
+fuse/
+	FUSE (userspace filesystem) built on top of libguestfs.
+
 haskell/
         Haskell bindings.
 
diff --git a/Makefile.am b/Makefile.am
index 0b905ca..a4f4b0b 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -34,6 +34,10 @@ if HAVE_TOOLS
 SUBDIRS += tools
 endif
 
+if HAVE_FUSE
+SUBDIRS += fuse
+endif
+
 if HAVE_OCAML
 SUBDIRS += ocaml ocaml/examples
 endif
@@ -134,6 +138,7 @@ html/recipes.html: $(wildcard recipes/*.sh) $(wildcard
recipes/*.html) $(wildcar
 HTMLFILES = \
 	html/guestfs.3.html \
 	html/guestfish.1.html \
+	html/guestmount.1.html \
 	html/hivex.3.html \
 	html/hivexget.1.html \
 	html/hivexml.1.html \
diff --git a/README b/README
index 41902ea..0877775 100644
--- a/README
+++ b/README
@@ -52,6 +52,8 @@ Requirements
 
 - libxml2
 
+- (Optional) FUSE to build the FUSE module
+
 - (Optional) Augeas (http://augeas.net/)
 
 - perldoc (pod2man, pod2text) to generate the manual pages and
diff --git a/TODO b/TODO
index fc14cdc..9c09557 100644
--- a/TODO
+++ b/TODO
@@ -12,33 +12,16 @@ Python bindings
 Ideas for the Python bindings:
 https://www.redhat.com/archives/fedora-virt/2009-April/msg00114.html
 
-FTP server or FUSE?
--------------------
+FUSE API
+--------
+
+The API needs more test coverage, particularly lesser-used system
+calls.
 
-Originally we had intended to implement an NFS server inside the
-appliance, which would allow the guest filesystems to be mounted on
-the host, and large changes to be made.  We eventually rejected the
-idea of using NFS, partly because it requires root to mount
-filesystems in the host, and partly because of problems handling UID
-mappings between host and guest filesystem.
-
-Then we look at implementing an FTP server instead.  FTP clients are
-widely available for many languages, don't require root, and don't
-have any UID mapping problems.  However there is the problem of
-getting the TCP connection into the guest, and that FTP requires a
-secondary data connection either in or out of the guest (the NFS
-situation is even more dire).
-
-Thirdly we looked at implementing a FUSE-based filesystem.  This is
-plausible - it could be implemented just by adding the additional FUSE
-operations to the standard guestfs(3) API, and then implementing a
-simple FUSE daemon.  (The FUSE website has some very helpful
-documentation and examples).  I [RWMJ] am not particularly convinced
-that a FUSE-based filesystem would really be useful to anyone, but am
-prepared to accept patches if someone does all the work.
-
-See also the mountlo project:
-http://sourceforge.net/project/showfiles.php?group_id=121684&package_id=150116
+The big unresolved issue is UID/GID mapping between guest filesystem
+IDs and the host.  It's not easy to automate this because you need
+extra details about the guest itself in order to get to its
+UID->username map (eg. /etc/passwd from the guest).
 
 BufferIn
 --------
diff --git a/bootstrap b/bootstrap
index c92d1e1..0f8bf20 100755
--- a/bootstrap
+++ b/bootstrap
@@ -63,6 +63,8 @@ closeout
 gitlog-to-changelog
 gnu-make
 gnumakefile
+hash
+hash-pjw
 ignore-value
 maintainer-makefile
 manywarnings
diff --git a/configure.ac b/configure.ac
index b31c193..b500b5b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -421,6 +421,13 @@ PKG_CHECK_MODULES([LIBXML2], [libxml-2.0])
 AC_SUBST([LIBXML2_CFLAGS])
 AC_SUBST([LIBXML2_LIBS])
 
+dnl FUSE is optional to build the FUSE module.
+HAVE_FUSE=yes
+PKG_CHECK_MODULES([FUSE],[fuse],,[
+	HAVE_FUSE=no
+	AC_MSG_WARN([FUSE library and headers are missing, so optional FUSE module
won't be built])])
+AM_CONDITIONAL([HAVE_FUSE],[test "x$HAVE_FUSE" = "xyes"])
+
 dnl Check for OCaml (optional, for OCaml bindings).
 AC_PROG_OCAML
 AC_PROG_FINDLIB
@@ -729,6 +736,7 @@ AC_CONFIG_FILES([Makefile
                  gnulib/lib/Makefile
                  gnulib/tests/Makefile
 		 hivex/Makefile
+		 fuse/Makefile
                  ocaml/META perl/Makefile.PL])
 AC_OUTPUT
 
@@ -758,6 +766,7 @@ if test "x$HAVE_INSPECTOR" = "x"; then
echo "yes"; else echo "no"; fi
 echo -n "virt-* tools ........................ "
 if test "x$HAVE_TOOLS" = "x"; then echo "yes";
else echo "no"; fi
 echo "supermin appliance .................. $enable_supermin"
+echo "FUSE filesystem ..................... $HAVE_FUSE"
 echo
 echo "If any optional component is configured 'no' when you
expected 'yes'"
 echo "then you should check the preceeding messages."
diff --git a/daemon/xattr.c b/daemon/xattr.c
index fe1d2b6..d16939f 100644
--- a/daemon/xattr.c
+++ b/daemon/xattr.c
@@ -376,8 +376,8 @@ do_lxattrlist (const char *path, char *const *names)
       }
 
       CHROOT_IN;
-      vlen = getxattr (pathname, &buf[i],
-                       entry[j+1].attrval.attrval_val, vlen);
+      vlen = lgetxattr (pathname, &buf[i],
+                        entry[j+1].attrval.attrval_val, vlen);
       CHROOT_OUT;
       if (vlen == -1) {
         reply_with_perror ("getxattr");
diff --git a/fuse/Makefile.am b/fuse/Makefile.am
new file mode 100644
index 0000000..5d5ea30
--- /dev/null
+++ b/fuse/Makefile.am
@@ -0,0 +1,62 @@
+# libguestfs
+# Copyright (C) 2009 Red Hat Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+EXTRA_DIST = fusexmp.c fusexmp_fh.c
+
+if HAVE_FUSE
+
+bin_PROGRAMS = guestmount
+
+guestmount_SOURCES = \
+	dircache.c \
+	dircache.h \
+	guestmount.c
+
+guestmount_CFLAGS = \
+	-I$(top_srcdir)/src -I$(top_builddir)/src \
+	-I$(srcdir)/../gnulib/lib -I../gnulib/lib \
+	-DGUESTFS_DEFAULT_PATH='"$(libdir)/guestfs"' \
+	$(FUSE_CFLAGS) \
+	$(WARN_CFLAGS) $(WERROR_CFLAGS)
+
+guestmount_LDADD = \
+	$(FUSE_LIBS) -lulockmgr \
+	$(top_builddir)/src/libguestfs.la \
+	../gnulib/lib/libgnu.la
+
+man_MANS = guestmount.1
+
+guestmount.1: guestmount.pod
+	$(POD2MAN) \
+	  --section 1 \
+	  -c "Virtualization Support" \
+	  --name "guestmount" \
+	  --release "$(PACKAGE_NAME)-$(PACKAGE_VERSION)" \
+	  $< > $@-t; mv $@-t $@
+
+noinst_DATA = \
+	$(top_builddir)/html/guestmount.1.html
+
+$(top_builddir)/html/guestmount.1.html: guestmount.pod
+	mkdir -p $(top_builddir)/html
+	cd $(top_builddir) && pod2html \
+	  --css 'pod.css' \
+	  --htmldir html \
+	  --outfile html/guestmount.1.html \
+	  fuse/guestmount.pod
+
+endif
diff --git a/fuse/dircache.c b/fuse/dircache.c
new file mode 100644
index 0000000..217a5c1
--- /dev/null
+++ b/fuse/dircache.c
@@ -0,0 +1,400 @@
+/* guestmount - mount guests using libguestfs and FUSE
+ * Copyright (C) 2009 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Derived from the example program 'fusexmp.c':
+ * Copyright (C) 2001-2007  Miklos Szeredi <miklos at szeredi.hu>
+ *
+ * This program can be distributed under the terms of the GNU GPL.
+ * See the file COPYING.
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <guestfs.h>
+
+#include "hash.h"
+#include "hash-pjw.h"
+
+#include "dircache.h"
+
+extern int verbose;
+extern int dir_cache_timeout;
+
+static inline char *
+bad_cast (char const *s)
+{
+  return (char *) s;
+}
+
+/* Note on attribute caching: FUSE can cache filesystem attributes for
+ * short periods of time (configurable via -o attr_timeout).  It
+ * doesn't cache xattrs, and in any case FUSE caching doesn't solve
+ * the problem that we have to make a series of guestfs_lstat and
+ * guestfs_lgetxattr calls when we first list a directory (thus, many
+ * round trips).
+ *
+ * For this reason, we also implement a readdir cache here which is
+ * invoked when a readdir call is made.  readdir is modified so that
+ * as well as reading the directory, it also requests all the stat
+ * structures, xattrs and readlinks of all entries in the directory,
+ * and these are added to the cache here (for a short, configurable
+ * period of time) in anticipation that they will be needed
+ * immediately afterwards, which is usually the case when the user is
+ * doing an "ls"-like operation.
+ *
+ * You can still use FUSE attribute caching on top of this mechanism
+ * if you like.
+ */
+
+struct lsc_entry {              /* lstat cache entry */
+  char *pathname;               /* full path to the file */
+  time_t timeout;               /* when this entry expires */
+  struct stat statbuf;          /* statbuf */
+};
+
+struct xac_entry {              /* xattr cache entry */
+  /* NB first two fields must be same as lsc_entry */
+  char *pathname;               /* full path to the file */
+  time_t timeout;               /* when this entry expires */
+  struct guestfs_xattr_list *xattrs;
+};
+
+struct rlc_entry {              /* readlink cache entry */
+  /* NB first two fields must be same as lsc_entry */
+  char *pathname;               /* full path to the file */
+  time_t timeout;               /* when this entry expires */
+  char *link;
+};
+
+static size_t
+gen_hash (void const *x, size_t table_size)
+{
+  struct lsc_entry const *p = x;
+  return hash_pjw (p->pathname, table_size);
+}
+
+static bool
+gen_compare (void const *x, void const *y)
+{
+  struct lsc_entry const *a = x;
+  struct lsc_entry const *b = y;
+  return strcmp (a->pathname, b->pathname) == 0;
+}
+
+static void
+lsc_free (void *x)
+{
+  if (x) {
+    struct lsc_entry *p = x;
+
+    free (p->pathname);
+    free (p);
+  }
+}
+
+static void
+xac_free (void *x)
+{
+  if (x) {
+    struct xac_entry *p = x;
+
+    guestfs_free_xattr_list (p->xattrs);
+    lsc_free (x);
+  }
+}
+
+static void
+rlc_free (void *x)
+{
+  if (x) {
+    struct rlc_entry *p = x;
+
+    free (p->link);
+    lsc_free (x);
+  }
+}
+
+static Hash_table *lsc_ht, *xac_ht, *rlc_ht;
+
+void
+init_dir_caches (void)
+{
+  lsc_ht = hash_initialize (1024, NULL, gen_hash, gen_compare, lsc_free);
+  xac_ht = hash_initialize (1024, NULL, gen_hash, gen_compare, xac_free);
+  rlc_ht = hash_initialize (1024, NULL, gen_hash, gen_compare, rlc_free);
+  if (!lsc_ht || !xac_ht || !rlc_ht) {
+    fprintf (stderr, "guestmount: could not initialize dir cache
hashtables\n");
+    exit (1);
+  }
+}
+
+struct gen_remove_data {
+  time_t now;
+  Hash_table *ht;
+  Hash_data_freer freer;
+};
+
+static bool
+gen_remove_if_expired (void *x, void *data)
+{
+  /* XXX hash_do_for_each was observed calling this function
+   * with x == NULL.
+   */
+  if (x) {
+    struct lsc_entry *p = x;
+    struct gen_remove_data *d = data;
+
+    if (p->timeout < d->now) {
+      if (verbose)
+        fprintf (stderr, "dir cache: expiring entry %p (%s)\n",
+                 p, p->pathname);
+      d->freer (hash_delete (d->ht, x));
+    }
+  }
+
+  return 1;
+}
+
+static void
+gen_remove_all_expired (Hash_table *ht, Hash_data_freer freer, time_t now)
+{
+  struct gen_remove_data data;
+  data.now = now;
+  data.ht = ht;
+  data.freer = freer;
+
+  /* Careful reading of the documentation to hash _seems_ to indicate
+   * that this is safe, _provided_ we use the default thresholds (in
+   * particular, no shrink threshold).
+   */
+  hash_do_for_each (ht, gen_remove_if_expired, &data);
+}
+
+void
+dir_cache_remove_all_expired (time_t now)
+{
+  gen_remove_all_expired (lsc_ht, lsc_free, now);
+  gen_remove_all_expired (xac_ht, xac_free, now);
+  gen_remove_all_expired (rlc_ht, rlc_free, now);
+}
+
+static int
+gen_replace (Hash_table *ht, struct lsc_entry *new_entry, Hash_data_freer
freer)
+{
+  struct lsc_entry *old_entry;
+
+  old_entry = hash_delete (ht, new_entry);
+  freer (old_entry);
+
+  if (verbose && old_entry)
+    fprintf (stderr, "dir cache: this entry replaced old entry %p
(%s)\n",
+             old_entry, old_entry->pathname);
+
+  old_entry = hash_insert (ht, new_entry);
+  if (old_entry == NULL) {
+    perror ("hash_insert");
+    freer (new_entry);
+    return -1;
+  }
+  assert (old_entry == new_entry);
+
+  return 0;
+}
+
+int
+lsc_insert (const char *path, const char *name, time_t now,
+            struct stat const *statbuf)
+{
+  struct lsc_entry *entry;
+
+  entry = malloc (sizeof *entry);
+  if (entry == NULL) {
+    perror ("malloc");
+    return -1;
+  }
+
+  size_t len = strlen (path) + strlen (name) + 2;
+  entry->pathname = malloc (len);
+  if (entry->pathname == NULL) {
+    perror ("malloc");
+    free (entry);
+    return -1;
+  }
+  if (strcmp (path, "/") == 0)
+    snprintf (entry->pathname, len, "/%s", name);
+  else
+    snprintf (entry->pathname, len, "%s/%s", path, name);
+
+  memcpy (&entry->statbuf, statbuf, sizeof entry->statbuf);
+
+  entry->timeout = now + dir_cache_timeout;
+
+  if (verbose)
+    fprintf (stderr, "dir cache: inserting lstat entry %p (%s)\n",
+             entry, entry->pathname);
+
+  return gen_replace (lsc_ht, entry, lsc_free);
+}
+
+int
+xac_insert (const char *path, const char *name, time_t now,
+            struct guestfs_xattr_list *xattrs)
+{
+  struct xac_entry *entry;
+
+  entry = malloc (sizeof *entry);
+  if (entry == NULL) {
+    perror ("malloc");
+    return -1;
+  }
+
+  size_t len = strlen (path) + strlen (name) + 2;
+  entry->pathname = malloc (len);
+  if (entry->pathname == NULL) {
+    perror ("malloc");
+    free (entry);
+    return -1;
+  }
+  if (strcmp (path, "/") == 0)
+    snprintf (entry->pathname, len, "/%s", name);
+  else
+    snprintf (entry->pathname, len, "%s/%s", path, name);
+
+  entry->xattrs = xattrs;
+
+  entry->timeout = now + dir_cache_timeout;
+
+  if (verbose)
+    fprintf (stderr, "dir cache: inserting xattr entry %p (%s)\n",
+             entry, entry->pathname);
+
+  return gen_replace (xac_ht, (struct lsc_entry *) entry, xac_free);
+}
+
+int
+rlc_insert (const char *path, const char *name, time_t now,
+            char *link)
+{
+  struct rlc_entry *entry;
+
+  entry = malloc (sizeof *entry);
+  if (entry == NULL) {
+    perror ("malloc");
+    return -1;
+  }
+
+  size_t len = strlen (path) + strlen (name) + 2;
+  entry->pathname = malloc (len);
+  if (entry->pathname == NULL) {
+    perror ("malloc");
+    free (entry);
+    return -1;
+  }
+  if (strcmp (path, "/") == 0)
+    snprintf (entry->pathname, len, "/%s", name);
+  else
+    snprintf (entry->pathname, len, "%s/%s", path, name);
+
+  entry->link = link;
+
+  entry->timeout = now + dir_cache_timeout;
+
+  if (verbose)
+    fprintf (stderr, "dir cache: inserting readlink entry %p (%s)\n",
+             entry, entry->pathname);
+
+  return gen_replace (rlc_ht, (struct lsc_entry *) entry, rlc_free);
+}
+
+const struct stat *
+lsc_lookup (const char *pathname)
+{
+  const struct lsc_entry key = { .pathname = bad_cast (pathname) };
+  struct lsc_entry *entry;
+  time_t now;
+
+  time (&now);
+
+  entry = hash_lookup (lsc_ht, &key);
+  if (entry && entry->timeout >= now)
+    return &entry->statbuf;
+  else
+    return NULL;
+}
+
+const struct guestfs_xattr_list *
+xac_lookup (const char *pathname)
+{
+  const struct xac_entry key = { .pathname = bad_cast (pathname) };
+  struct xac_entry *entry;
+  time_t now;
+
+  time (&now);
+
+  entry = hash_lookup (xac_ht, &key);
+  if (entry && entry->timeout >= now)
+    return entry->xattrs;
+  else
+    return NULL;
+}
+
+const char *
+rlc_lookup (const char *pathname)
+{
+  const struct rlc_entry key = { .pathname = bad_cast (pathname) };
+  struct rlc_entry *entry;
+  time_t now;
+
+  time (&now);
+
+  entry = hash_lookup (rlc_ht, &key);
+  if (entry && entry->timeout >= now)
+    return entry->link;
+  else
+    return NULL;
+}
+
+static void
+lsc_remove (Hash_table *ht, const char *pathname, Hash_data_freer freer)
+{
+  const struct lsc_entry key = { .pathname = bad_cast (pathname) };
+  struct lsc_entry *entry;
+
+  entry = hash_delete (ht, &key);
+
+  if (verbose)
+    fprintf (stderr, "dir cache: invalidating entry %p (%s)\n",
+             entry, entry->pathname);
+
+  freer (entry);
+}
+
+void
+dir_cache_invalidate (const char *path)
+{
+  lsc_remove (lsc_ht, path, lsc_free);
+  lsc_remove (xac_ht, path, xac_free);
+  lsc_remove (rlc_ht, path, rlc_free);
+}
diff --git a/fuse/dircache.h b/fuse/dircache.h
new file mode 100644
index 0000000..6404e72
--- /dev/null
+++ b/fuse/dircache.h
@@ -0,0 +1,43 @@
+/* guestmount - mount guests using libguestfs and FUSE
+ * Copyright (C) 2009 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Derived from the example program 'fusexmp.c':
+ * Copyright (C) 2001-2007  Miklos Szeredi <miklos at szeredi.hu>
+ *
+ * This program can be distributed under the terms of the GNU GPL.
+ * See the file COPYING.
+ */
+
+#ifndef GUESTMOUNT_DIRCACHE_H
+#define GUESTMOUNT_DIRCACHE_H 1
+
+#include <time.h>
+#include <sys/stat.h>
+#include <guestfs.h>
+
+extern void init_dir_caches (void);
+extern void dir_cache_remove_all_expired (time_t now);
+extern void dir_cache_invalidate (const char *path);
+
+extern int lsc_insert (const char *path, const char *name, time_t now, struct
stat const *statbuf);
+extern int xac_insert (const char *path, const char *name, time_t now, struct
guestfs_xattr_list *xattrs);
+extern int rlc_insert (const char *path, const char *name, time_t now, char
*link);
+extern const struct stat *lsc_lookup (const char *pathname);
+extern const struct guestfs_xattr_list *xac_lookup (const char *pathname);
+extern const char *rlc_lookup (const char *pathname);
+
+#endif /* GUESTMOUNT_DIRCACHE_H */
diff --git a/fuse/fusexmp.c b/fuse/fusexmp.c
new file mode 100644
index 0000000..083bbea
--- /dev/null
+++ b/fuse/fusexmp.c
@@ -0,0 +1,385 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos at szeredi.hu>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall `pkg-config fuse --cflags --libs` fusexmp.c -o fusexmp
+*/
+
+#define FUSE_USE_VERSION 26
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef linux
+/* For pread()/pwrite() */
+#define _XOPEN_SOURCE 500
+#endif
+
+#include <fuse.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <sys/time.h>
+#ifdef HAVE_SETXATTR
+#include <sys/xattr.h>
+#endif
+
+static int xmp_getattr(const char *path, struct stat *stbuf)
+{
+	int res;
+
+	res = lstat(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_access(const char *path, int mask)
+{
+	int res;
+
+	res = access(path, mask);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_readlink(const char *path, char *buf, size_t size)
+{
+	int res;
+
+	res = readlink(path, buf, size - 1);
+	if (res == -1)
+		return -errno;
+
+	buf[res] = '\0';
+	return 0;
+}
+
+
+static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
+		       off_t offset, struct fuse_file_info *fi)
+{
+	DIR *dp;
+	struct dirent *de;
+
+	(void) offset;
+	(void) fi;
+
+	dp = opendir(path);
+	if (dp == NULL)
+		return -errno;
+
+	while ((de = readdir(dp)) != NULL) {
+		struct stat st;
+		memset(&st, 0, sizeof(st));
+		st.st_ino = de->d_ino;
+		st.st_mode = de->d_type << 12;
+		if (filler(buf, de->d_name, &st, 0))
+			break;
+	}
+
+	closedir(dp);
+	return 0;
+}
+
+static int xmp_mknod(const char *path, mode_t mode, dev_t rdev)
+{
+	int res;
+
+	/* On Linux this could just be 'mknod(path, mode, rdev)' but this
+	   is more portable */
+	if (S_ISREG(mode)) {
+		res = open(path, O_CREAT | O_EXCL | O_WRONLY, mode);
+		if (res >= 0)
+			res = close(res);
+	} else if (S_ISFIFO(mode))
+		res = mkfifo(path, mode);
+	else
+		res = mknod(path, mode, rdev);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_mkdir(const char *path, mode_t mode)
+{
+	int res;
+
+	res = mkdir(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_unlink(const char *path)
+{
+	int res;
+
+	res = unlink(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rmdir(const char *path)
+{
+	int res;
+
+	res = rmdir(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_symlink(const char *from, const char *to)
+{
+	int res;
+
+	res = symlink(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rename(const char *from, const char *to)
+{
+	int res;
+
+	res = rename(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_link(const char *from, const char *to)
+{
+	int res;
+
+	res = link(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chmod(const char *path, mode_t mode)
+{
+	int res;
+
+	res = chmod(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chown(const char *path, uid_t uid, gid_t gid)
+{
+	int res;
+
+	res = lchown(path, uid, gid);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_truncate(const char *path, off_t size)
+{
+	int res;
+
+	res = truncate(path, size);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_utimens(const char *path, const struct timespec ts[2])
+{
+	int res;
+	struct timeval tv[2];
+
+	tv[0].tv_sec = ts[0].tv_sec;
+	tv[0].tv_usec = ts[0].tv_nsec / 1000;
+	tv[1].tv_sec = ts[1].tv_sec;
+	tv[1].tv_usec = ts[1].tv_nsec / 1000;
+
+	res = utimes(path, tv);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_open(const char *path, struct fuse_file_info *fi)
+{
+	int res;
+
+	res = open(path, fi->flags);
+	if (res == -1)
+		return -errno;
+
+	close(res);
+	return 0;
+}
+
+static int xmp_read(const char *path, char *buf, size_t size, off_t offset,
+		    struct fuse_file_info *fi)
+{
+	int fd;
+	int res;
+
+	(void) fi;
+	fd = open(path, O_RDONLY);
+	if (fd == -1)
+		return -errno;
+
+	res = pread(fd, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	close(fd);
+	return res;
+}
+
+static int xmp_write(const char *path, const char *buf, size_t size,
+		     off_t offset, struct fuse_file_info *fi)
+{
+	int fd;
+	int res;
+
+	(void) fi;
+	fd = open(path, O_WRONLY);
+	if (fd == -1)
+		return -errno;
+
+	res = pwrite(fd, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	close(fd);
+	return res;
+}
+
+static int xmp_statfs(const char *path, struct statvfs *stbuf)
+{
+	int res;
+
+	res = statvfs(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_release(const char *path, struct fuse_file_info *fi)
+{
+	/* Just a stub.	 This method is optional and can safely be left
+	   unimplemented */
+
+	(void) path;
+	(void) fi;
+	return 0;
+}
+
+static int xmp_fsync(const char *path, int isdatasync,
+		     struct fuse_file_info *fi)
+{
+	/* Just a stub.	 This method is optional and can safely be left
+	   unimplemented */
+
+	(void) path;
+	(void) isdatasync;
+	(void) fi;
+	return 0;
+}
+
+#ifdef HAVE_SETXATTR
+/* xattr operations are optional and can safely be left unimplemented */
+static int xmp_setxattr(const char *path, const char *name, const char *value,
+			size_t size, int flags)
+{
+	int res = lsetxattr(path, name, value, size, flags);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+
+static int xmp_getxattr(const char *path, const char *name, char *value,
+			size_t size)
+{
+	int res = lgetxattr(path, name, value, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_listxattr(const char *path, char *list, size_t size)
+{
+	int res = llistxattr(path, list, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_removexattr(const char *path, const char *name)
+{
+	int res = lremovexattr(path, name);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+#endif /* HAVE_SETXATTR */
+
+static struct fuse_operations xmp_oper = {
+	.getattr	= xmp_getattr,
+	.access		= xmp_access,
+	.readlink	= xmp_readlink,
+	.readdir	= xmp_readdir,
+	.mknod		= xmp_mknod,
+	.mkdir		= xmp_mkdir,
+	.symlink	= xmp_symlink,
+	.unlink		= xmp_unlink,
+	.rmdir		= xmp_rmdir,
+	.rename		= xmp_rename,
+	.link		= xmp_link,
+	.chmod		= xmp_chmod,
+	.chown		= xmp_chown,
+	.truncate	= xmp_truncate,
+	.utimens	= xmp_utimens,
+	.open		= xmp_open,
+	.read		= xmp_read,
+	.write		= xmp_write,
+	.statfs		= xmp_statfs,
+	.release	= xmp_release,
+	.fsync		= xmp_fsync,
+#ifdef HAVE_SETXATTR
+	.setxattr	= xmp_setxattr,
+	.getxattr	= xmp_getxattr,
+	.listxattr	= xmp_listxattr,
+	.removexattr	= xmp_removexattr,
+#endif
+};
+
+int main(int argc, char *argv[])
+{
+	umask(0);
+	return fuse_main(argc, argv, &xmp_oper, NULL);
+}
diff --git a/fuse/fusexmp_fh.c b/fuse/fusexmp_fh.c
new file mode 100644
index 0000000..b86d3f6
--- /dev/null
+++ b/fuse/fusexmp_fh.c
@@ -0,0 +1,495 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos at szeredi.hu>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall `pkg-config fuse --cflags --libs` -lulockmgr fusexmp_fh.c -o
fusexmp_fh
+*/
+
+#define FUSE_USE_VERSION 26
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+
+#include <fuse.h>
+#include <ulockmgr.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <sys/time.h>
+#ifdef HAVE_SETXATTR
+#include <sys/xattr.h>
+#endif
+
+static int xmp_getattr(const char *path, struct stat *stbuf)
+{
+	int res;
+
+	res = lstat(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_fgetattr(const char *path, struct stat *stbuf,
+			struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+
+	res = fstat(fi->fh, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_access(const char *path, int mask)
+{
+	int res;
+
+	res = access(path, mask);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_readlink(const char *path, char *buf, size_t size)
+{
+	int res;
+
+	res = readlink(path, buf, size - 1);
+	if (res == -1)
+		return -errno;
+
+	buf[res] = '\0';
+	return 0;
+}
+
+struct xmp_dirp {
+	DIR *dp;
+	struct dirent *entry;
+	off_t offset;
+};
+
+static int xmp_opendir(const char *path, struct fuse_file_info *fi)
+{
+	int res;
+	struct xmp_dirp *d = malloc(sizeof(struct xmp_dirp));
+	if (d == NULL)
+		return -ENOMEM;
+
+	d->dp = opendir(path);
+	if (d->dp == NULL) {
+		res = -errno;
+		free(d);
+		return res;
+	}
+	d->offset = 0;
+	d->entry = NULL;
+
+	fi->fh = (unsigned long) d;
+	return 0;
+}
+
+static inline struct xmp_dirp *get_dirp(struct fuse_file_info *fi)
+{
+	return (struct xmp_dirp *) (uintptr_t) fi->fh;
+}
+
+static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
+		       off_t offset, struct fuse_file_info *fi)
+{
+	struct xmp_dirp *d = get_dirp(fi);
+
+	(void) path;
+	if (offset != d->offset) {
+		seekdir(d->dp, offset);
+		d->entry = NULL;
+		d->offset = offset;
+	}
+	while (1) {
+		struct stat st;
+		off_t nextoff;
+
+		if (!d->entry) {
+			d->entry = readdir(d->dp);
+			if (!d->entry)
+				break;
+		}
+
+		memset(&st, 0, sizeof(st));
+		st.st_ino = d->entry->d_ino;
+		st.st_mode = d->entry->d_type << 12;
+		nextoff = telldir(d->dp);
+		if (filler(buf, d->entry->d_name, &st, nextoff))
+			break;
+
+		d->entry = NULL;
+		d->offset = nextoff;
+	}
+
+	return 0;
+}
+
+static int xmp_releasedir(const char *path, struct fuse_file_info *fi)
+{
+	struct xmp_dirp *d = get_dirp(fi);
+	(void) path;
+	closedir(d->dp);
+	free(d);
+	return 0;
+}
+
+static int xmp_mknod(const char *path, mode_t mode, dev_t rdev)
+{
+	int res;
+
+	if (S_ISFIFO(mode))
+		res = mkfifo(path, mode);
+	else
+		res = mknod(path, mode, rdev);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_mkdir(const char *path, mode_t mode)
+{
+	int res;
+
+	res = mkdir(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_unlink(const char *path)
+{
+	int res;
+
+	res = unlink(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rmdir(const char *path)
+{
+	int res;
+
+	res = rmdir(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_symlink(const char *from, const char *to)
+{
+	int res;
+
+	res = symlink(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rename(const char *from, const char *to)
+{
+	int res;
+
+	res = rename(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_link(const char *from, const char *to)
+{
+	int res;
+
+	res = link(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chmod(const char *path, mode_t mode)
+{
+	int res;
+
+	res = chmod(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chown(const char *path, uid_t uid, gid_t gid)
+{
+	int res;
+
+	res = lchown(path, uid, gid);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_truncate(const char *path, off_t size)
+{
+	int res;
+
+	res = truncate(path, size);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_ftruncate(const char *path, off_t size,
+			 struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+
+	res = ftruncate(fi->fh, size);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_utimens(const char *path, const struct timespec ts[2])
+{
+	int res;
+	struct timeval tv[2];
+
+	tv[0].tv_sec = ts[0].tv_sec;
+	tv[0].tv_usec = ts[0].tv_nsec / 1000;
+	tv[1].tv_sec = ts[1].tv_sec;
+	tv[1].tv_usec = ts[1].tv_nsec / 1000;
+
+	res = utimes(path, tv);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_create(const char *path, mode_t mode, struct fuse_file_info *fi)
+{
+	int fd;
+
+	fd = open(path, fi->flags, mode);
+	if (fd == -1)
+		return -errno;
+
+	fi->fh = fd;
+	return 0;
+}
+
+static int xmp_open(const char *path, struct fuse_file_info *fi)
+{
+	int fd;
+
+	fd = open(path, fi->flags);
+	if (fd == -1)
+		return -errno;
+
+	fi->fh = fd;
+	return 0;
+}
+
+static int xmp_read(const char *path, char *buf, size_t size, off_t offset,
+		    struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+	res = pread(fi->fh, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	return res;
+}
+
+static int xmp_write(const char *path, const char *buf, size_t size,
+		     off_t offset, struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+	res = pwrite(fi->fh, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	return res;
+}
+
+static int xmp_statfs(const char *path, struct statvfs *stbuf)
+{
+	int res;
+
+	res = statvfs(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_flush(const char *path, struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+	/* This is called from every close on an open file, so call the
+	   close on the underlying filesystem.	But since flush may be
+	   called multiple times for an open file, this must not really
+	   close the file.  This is important if used on a network
+	   filesystem like NFS which flush the data/metadata on close() */
+	res = close(dup(fi->fh));
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_release(const char *path, struct fuse_file_info *fi)
+{
+	(void) path;
+	close(fi->fh);
+
+	return 0;
+}
+
+static int xmp_fsync(const char *path, int isdatasync,
+		     struct fuse_file_info *fi)
+{
+	int res;
+	(void) path;
+
+#ifndef HAVE_FDATASYNC
+	(void) isdatasync;
+#else
+	if (isdatasync)
+		res = fdatasync(fi->fh);
+	else
+#endif
+		res = fsync(fi->fh);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+#ifdef HAVE_SETXATTR
+/* xattr operations are optional and can safely be left unimplemented */
+static int xmp_setxattr(const char *path, const char *name, const char *value,
+			size_t size, int flags)
+{
+	int res = lsetxattr(path, name, value, size, flags);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+
+static int xmp_getxattr(const char *path, const char *name, char *value,
+			size_t size)
+{
+	int res = lgetxattr(path, name, value, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_listxattr(const char *path, char *list, size_t size)
+{
+	int res = llistxattr(path, list, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_removexattr(const char *path, const char *name)
+{
+	int res = lremovexattr(path, name);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+#endif /* HAVE_SETXATTR */
+
+static int xmp_lock(const char *path, struct fuse_file_info *fi, int cmd,
+		    struct flock *lock)
+{
+	(void) path;
+
+	return ulockmgr_op(fi->fh, cmd, lock, &fi->lock_owner,
+			   sizeof(fi->lock_owner));
+}
+
+static struct fuse_operations xmp_oper = {
+	.getattr	= xmp_getattr,
+	.fgetattr	= xmp_fgetattr,
+	.access		= xmp_access,
+	.readlink	= xmp_readlink,
+	.opendir	= xmp_opendir,
+	.readdir	= xmp_readdir,
+	.releasedir	= xmp_releasedir,
+	.mknod		= xmp_mknod,
+	.mkdir		= xmp_mkdir,
+	.symlink	= xmp_symlink,
+	.unlink		= xmp_unlink,
+	.rmdir		= xmp_rmdir,
+	.rename		= xmp_rename,
+	.link		= xmp_link,
+	.chmod		= xmp_chmod,
+	.chown		= xmp_chown,
+	.truncate	= xmp_truncate,
+	.ftruncate	= xmp_ftruncate,
+	.utimens	= xmp_utimens,
+	.create		= xmp_create,
+	.open		= xmp_open,
+	.read		= xmp_read,
+	.write		= xmp_write,
+	.statfs		= xmp_statfs,
+	.flush		= xmp_flush,
+	.release	= xmp_release,
+	.fsync		= xmp_fsync,
+#ifdef HAVE_SETXATTR
+	.setxattr	= xmp_setxattr,
+	.getxattr	= xmp_getxattr,
+	.listxattr	= xmp_listxattr,
+	.removexattr	= xmp_removexattr,
+#endif
+	.lock		= xmp_lock,
+
+	.flag_nullpath_ok = 1,
+};
+
+int main(int argc, char *argv[])
+{
+	umask(0);
+	return fuse_main(argc, argv, &xmp_oper, NULL);
+}
diff --git a/fuse/guestmount.c b/fuse/guestmount.c
new file mode 100644
index 0000000..f80ae34
--- /dev/null
+++ b/fuse/guestmount.c
@@ -0,0 +1,1063 @@
+/* guestmount - mount guests using libguestfs and FUSE
+ * Copyright (C) 2009 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Derived from the example program 'fusexmp.c':
+ * Copyright (C) 2001-2007  Miklos Szeredi <miklos at szeredi.hu>
+ *
+ * This program can be distributed under the terms of the GNU GPL.
+ * See the file COPYING.
+ */
+
+#define FUSE_USE_VERSION 26
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <signal.h>
+#include <time.h>
+#include <assert.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <fuse.h>
+#include <guestfs.h>
+
+#include "progname.h"
+
+#include "dircache.h"
+
+/* See <attr/xattr.h> */
+#ifndef ENOATTR
+#define ENOATTR ENODATA
+#endif
+
+#ifdef HAVE_GETTEXT
+#include "gettext.h"
+#define _(str) dgettext(PACKAGE, (str))
+//#define N_(str) dgettext(PACKAGE, (str))
+#else
+#define _(str) str
+//#define N_(str) str
+#endif
+
+static inline char *
+bad_cast (char const *s)
+{
+  return (char *) s;
+}
+
+static guestfs_h *g = NULL;
+static int read_only = 0;
+int verbose = 0;
+int dir_cache_timeout = 5;
+
+/* This is ugly: guestfs errors are strings, FUSE wants -errno.  We
+ * have to do the conversion as best we can.
+ */
+#define MAX_ERRNO 256
+
+static int
+error (void)
+{
+  int i;
+  const char *err = guestfs_last_error (g);
+
+  if (!err)
+    return -EINVAL;
+
+  /* Print the real error message on stderr. */
+  fprintf (stderr, "%s\n", err);
+
+  /* Add a few of our own ... */
+
+  /* This indicates guestfsd died.  Translate into a hard EIO error.
+   * Arguably we could relaunch the guest if we hit this error.
+   */
+  if (strstr (err, "call launch before using this function"))
+    return -EIO;
+
+  /* See if it matches an errno string in the host. */
+  for (i = 0; i < MAX_ERRNO; ++i) {
+    const char *e = strerror (i);
+    if (e && strstr (err, e) != NULL)
+      return -i;
+  }
+
+  /* Too bad, return a generic error. */
+  return -EINVAL;
+}
+
+static struct guestfs_xattr_list *
+copy_xattr_list (const struct guestfs_xattr *first, size_t num)
+{
+  struct guestfs_xattr_list *xattrs;
+
+  xattrs = malloc (sizeof *xattrs);
+  if (xattrs == NULL) {
+    perror ("malloc");
+    return NULL;
+  }
+
+  xattrs->len = num;
+  xattrs->val = malloc (num * sizeof (struct guestfs_xattr));
+  if (xattrs->val == NULL) {
+    perror ("malloc");
+    free (xattrs);
+    return NULL;
+  }
+
+  size_t i;
+  for (i = 0; i < num; ++i) {
+    xattrs->val[i].attrname = strdup (first[i].attrname);
+    xattrs->val[i].attrval_len = first[i].attrval_len;
+    xattrs->val[i].attrval = malloc (first[i].attrval_len);
+    memcpy (xattrs->val[i].attrval, first[i].attrval, first[i].attrval_len);
+  }
+
+  return xattrs;
+}
+
+static int
+fg_readdir (const char *path, void *buf, fuse_fill_dir_t filler,
+            off_t offset, struct fuse_file_info *fi)
+{
+  time_t now;
+  time (&now);
+
+  dir_cache_remove_all_expired (now);
+
+  struct guestfs_dirent_list *ents;
+
+  ents = guestfs_readdir (g, path);
+  if (ents == NULL)
+    return error ();
+
+  size_t i;
+  for (i = 0; i < ents->len; ++i) {
+    struct stat stat;
+    memset (&stat, 0, sizeof stat);
+
+    stat.st_ino = ents->val[i].ino;
+    switch (ents->val[i].ftyp) {
+    case 'b': stat.st_mode = S_IFBLK; break;
+    case 'c': stat.st_mode = S_IFCHR; break;
+    case 'd': stat.st_mode = S_IFDIR; break;
+    case 'f': stat.st_mode = S_IFIFO; break;
+    case 'l': stat.st_mode = S_IFLNK; break;
+    case 'r': stat.st_mode = S_IFREG; break;
+    case 's': stat.st_mode = S_IFSOCK; break;
+    case 'u':
+    case '?':
+    default:  stat.st_mode = 0;
+    }
+
+    /* Copied from the example, which also ignores 'offset'.  I'm
+     * not quite sure how this is ever supposed to work on large
+     * directories. XXX
+     */
+    if (filler (buf, ents->val[i].name, &stat, 0))
+      break;
+  }
+
+  /* Now prepopulate the directory caches.  This step is just an
+   * optimization, don't worry if it fails.
+   */
+  char **names = malloc ((ents->len + 1) * sizeof (char *));
+  if (names) {
+    for (i = 0; i < ents->len; ++i)
+      names[i] = ents->val[i].name;
+    names[i] = NULL;
+
+    struct guestfs_stat_list *ss = guestfs_lstatlist (g, path, names);
+    if (ss) {
+      for (i = 0; i < ss->len; ++i) {
+        if (ss->val[i].ino >= 0) {
+          struct stat statbuf;
+
+          statbuf.st_dev = ss->val[i].dev;
+          statbuf.st_ino = ss->val[i].ino;
+          statbuf.st_mode = ss->val[i].mode;
+          statbuf.st_nlink = ss->val[i].nlink;
+          statbuf.st_uid = ss->val[i].uid;
+          statbuf.st_gid = ss->val[i].gid;
+          statbuf.st_rdev = ss->val[i].rdev;
+          statbuf.st_size = ss->val[i].size;
+          statbuf.st_blksize = ss->val[i].blksize;
+          statbuf.st_blocks = ss->val[i].blocks;
+          statbuf.st_atime = ss->val[i].atime;
+          statbuf.st_mtime = ss->val[i].mtime;
+          statbuf.st_ctime = ss->val[i].ctime;
+
+          lsc_insert (path, names[i], now, &statbuf);
+        }
+      }
+      guestfs_free_stat_list (ss);
+    }
+
+    struct guestfs_xattr_list *xattrs = guestfs_lxattrlist (g, path, names);
+    if (xattrs) {
+      size_t ni, num;
+      struct guestfs_xattr *first;
+      struct guestfs_xattr_list *copy;
+      for (i = 0, ni = 0; i < xattrs->len; ++i, ++ni) {
+        assert (strlen (xattrs->val[i].attrname) == 0);
+        if (xattrs->val[i].attrval_len > 0) {
+          ++i;
+          first = &xattrs->val[i];
+          num = 0;
+          for (; i < xattrs->len && strlen
(xattrs->val[i].attrname) > 0; ++i)
+            num++;
+
+          copy = copy_xattr_list (first, num);
+          if (copy)
+            xac_insert (path, names[ni], now, copy);
+
+          i--;
+        }
+      }
+      guestfs_free_xattr_list (xattrs);
+    }
+
+    char **links = guestfs_readlinklist (g, path, names);
+    if (links) {
+      for (i = 0; names[i] != NULL; ++i) {
+        if (links[i][0])
+          /* Note that rlc_insert owns the string links[i] after this, */
+          rlc_insert (path, names[i], now, links[i]);
+        else
+          /* which is why we have to free links[i] here. */
+          free (links[i]);
+      }
+      free (links);             /* free the array, not the strings */
+    }
+
+    free (names);
+  }
+
+  guestfs_free_dirent_list (ents);
+
+  return 0;
+}
+
+static int
+fg_getattr (const char *path, struct stat *statbuf)
+{
+  const struct stat *buf;
+
+  buf = lsc_lookup (path);
+  if (buf) {
+    memcpy (statbuf, buf, sizeof *statbuf);
+    return 0;
+  }
+
+  struct guestfs_stat *r;
+
+  r = guestfs_lstat (g, path);
+  if (r == NULL)
+    return error ();
+
+  statbuf->st_dev = r->dev;
+  statbuf->st_ino = r->ino;
+  statbuf->st_mode = r->mode;
+  statbuf->st_nlink = r->nlink;
+  statbuf->st_uid = r->uid;
+  statbuf->st_gid = r->gid;
+  statbuf->st_rdev = r->rdev;
+  statbuf->st_size = r->size;
+  statbuf->st_blksize = r->blksize;
+  statbuf->st_blocks = r->blocks;
+  statbuf->st_atime = r->atime;
+  statbuf->st_mtime = r->mtime;
+  statbuf->st_ctime = r->ctime;
+
+  guestfs_free_stat (r);
+
+  return 0;
+}
+
+/* XXX It's not clear what access is being tested here.  If this
+ * daemon runs as root, then access always succeeds.  guestfsd always
+ * runs as root, so no access test there is possible.
+ */
+static int
+fg_access (const char *path, int mask)
+{
+  int r = guestfs_exists (g, path);
+  if (r == -1)
+    return error ();
+
+  if (mask == F_OK)
+    return r ? 0 : -EACCES;
+
+  int ok = 1;
+  /* if the file exists, it's readable */
+  if (mask & R_OK)
+    ok &= r;
+  /* if the file exists and we're not mounted r/o, it's writable
+   * XXX on error return -EROFS
+   */
+  if (mask & W_OK)
+    ok &= r & !read_only;
+  /* if the file exists, presume it's executable here */
+  if (mask & X_OK)
+    ok &= r;
+  return ok ? 0 : -EACCES;
+}
+
+static int
+fg_readlink (const char *path, char *buf, size_t size)
+{
+  const char *r;
+  int free_it = 0;
+
+  r = rlc_lookup (path);
+  if (!r) {
+    r = guestfs_readlink (g, path);
+    if (r == NULL)
+      return error ();
+    free_it = 1;
+  }
+
+  /* Note this is different from the real readlink(2) syscall.  FUSE wants
+   * the string to be always nul-terminated, even if truncated.
+   */
+  size_t len = strlen (r);
+  if (len > size - 1)
+    len = size - 1;
+
+  memcpy (buf, r, len);
+  buf[len] = '\0';
+
+  if (free_it)
+    free ((char *) r);
+
+  return 0;
+}
+
+static int
+fg_mknod (const char *path, mode_t mode, dev_t rdev)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  r = guestfs_mknod (g, mode, major (rdev), minor (rdev), path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_mkdir (const char *path, mode_t mode)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  r = guestfs_mkdir_mode (g, path, mode);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_unlink (const char *path)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  r = guestfs_rm (g, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_rmdir (const char *path)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  r = guestfs_rmdir (g, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_symlink (const char *from, const char *to)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (to);
+
+  r = guestfs_ln_s (g, to, from);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_rename (const char *from, const char *to)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (to);
+
+  /* XXX It's not clear how close the 'mv' command is to the
+   * rename syscall.  We might need to add the rename syscall
+   * to the guestfs(3) API.
+   */
+  r = guestfs_mv (g, from, to);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_link (const char *from, const char *to)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (to);
+
+  r = guestfs_ln (g, to, from);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_chmod (const char *path, mode_t mode)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  r = guestfs_chmod (g, mode, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_chown (const char *path, uid_t uid, gid_t gid)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  r = guestfs_lchown (g, uid, gid, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_truncate (const char *path, off_t size)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  r = guestfs_truncate_size (g, path, size);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_utimens (const char *path, const struct timespec ts[2])
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  time_t atsecs = ts[0].tv_sec;
+  long atnsecs = ts[0].tv_nsec;
+  time_t mtsecs = ts[1].tv_sec;
+  long mtnsecs = ts[1].tv_nsec;
+
+  if (atnsecs == UTIME_NOW)
+    atnsecs = -1;
+  if (atnsecs == UTIME_OMIT)
+    atnsecs = -2;
+  if (mtnsecs == UTIME_NOW)
+    mtnsecs = -1;
+  if (mtnsecs == UTIME_OMIT)
+    mtnsecs = -2;
+
+  r = guestfs_utimens (g, path, atsecs, atnsecs, mtsecs, mtnsecs);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+/* This call is quite hard to emulate through the guestfs(3) API.  In
+ * one sense it's a little like access (see above) because it tests
+ * whether opening a file would succeed given the flags.  But it also
+ * has side effects such as truncating the file if O_TRUNC is given.
+ * Therefore we need to emulate it ... painfully.
+ */
+static int
+fg_open (const char *path, struct fuse_file_info *fi)
+{
+  int r, exists;
+
+  if (fi->flags & O_WRONLY) {
+    if (read_only)
+      return -EROFS;
+  }
+
+  exists = guestfs_exists (g, path);
+  if (exists == -1)
+    return error ();
+
+  if (fi->flags & O_CREAT) {
+    if (read_only)
+      return -EROFS;
+
+    dir_cache_invalidate (path);
+
+    /* Exclusive?  File must not exist already. */
+    if (fi->flags & O_EXCL) {
+      if (exists)
+        return -EEXIST;
+    }
+
+    /* Create?  Touch it and optionally truncate it. */
+    r = guestfs_touch (g, path);
+    if (r == -1)
+      return error ();
+
+    if (fi->flags & O_TRUNC) {
+      r = guestfs_truncate (g, path);
+      if (r == -1)
+        return error ();
+    }
+  } else {
+    /* Not create, just check it exists. */
+    if (!exists)
+      return -ENOENT;
+  }
+
+  return 0;
+}
+
+static int
+fg_read (const char *path, char *buf, size_t size, off_t offset,
+         struct fuse_file_info *fi)
+{
+  /* XXX XXX returns random crap XXX XXX */
+  fprintf (stderr, "fg_read: %s: size %zu offset %zu\n",
+           path, size, offset);
+  return size;
+}
+
+static int
+fg_write (const char *path, const char *buf, size_t size,
+          off_t offset, struct fuse_file_info *fi)
+{
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  return -ENOSYS;               /* XXX */
+}
+
+static int
+fg_statfs (const char *path, struct statvfs *stbuf)
+{
+  struct guestfs_statvfs *r;
+
+  r = guestfs_statvfs (g, path);
+  if (r == NULL)
+    return error ();
+
+  stbuf->f_bsize = r->bsize;
+  stbuf->f_frsize = r->frsize;
+  stbuf->f_blocks = r->blocks;
+  stbuf->f_bfree = r->bfree;
+  stbuf->f_bavail = r->bavail;
+  stbuf->f_files = r->files;
+  stbuf->f_ffree = r->ffree;
+  stbuf->f_favail = r->favail;
+  stbuf->f_fsid = r->fsid;
+  stbuf->f_flag = r->flag;
+  stbuf->f_namemax = r->namemax;
+
+  guestfs_free_statvfs (r);
+
+  return 0;
+}
+
+static int
+fg_release (const char *path, struct fuse_file_info *fi)
+{
+  /* Just a stub. This method is optional and can safely be left
+   * unimplemented.
+   */
+  return 0;
+}
+
+/* Emulate this by calling sync. */
+static int fg_fsync(const char *path, int isdatasync,
+		     struct fuse_file_info *fi)
+{
+  int r;
+
+  r = guestfs_sync (g);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static int
+fg_setxattr (const char *path, const char *name, const char *value,
+             size_t size, int flags)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  /* XXX Underlying guestfs(3) API doesn't understand the flags. */
+  r = guestfs_lsetxattr (g, name, value, size, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+/* The guestfs(3) API for getting xattrs is much easier to use
+ * than the real syscall.  Unfortunately we now have to emulate
+ * the real syscall using that API :-(
+ */
+static int
+fg_getxattr (const char *path, const char *name, char *value,
+             size_t size)
+{
+  const struct guestfs_xattr_list *xattrs;
+  int free_attrs = 0;
+
+  xattrs = xac_lookup (path);
+  if (xattrs == NULL) {
+    xattrs = guestfs_lgetxattrs (g, path);
+    if (xattrs == NULL)
+      return error ();
+    free_attrs = 1;
+  }
+
+  size_t i;
+  int r = -ENOATTR;
+  for (i = 0; i < xattrs->len; ++i) {
+    if (strcmp (xattrs->val[i].attrname, name) == 0) {
+      size_t sz = xattrs->val[i].attrval_len;
+      if (sz > size)
+        sz = size;
+      memcpy (value, xattrs->val[i].attrval, sz);
+      r = 0;
+      break;
+    }
+  }
+
+  if (free_attrs)
+    guestfs_free_xattr_list ((struct guestfs_xattr_list *) xattrs);
+
+  return r;
+}
+
+/* Ditto as above. */
+static int
+fg_listxattr (const char *path, char *list, size_t size)
+{
+  const struct guestfs_xattr_list *xattrs;
+  int free_attrs = 0;
+
+  xattrs = xac_lookup (path);
+  if (xattrs == NULL) {
+    xattrs = guestfs_lgetxattrs (g, path);
+    if (xattrs == NULL)
+      return error ();
+    free_attrs = 1;
+  }
+
+  size_t i;
+  ssize_t copied = 0;
+  for (i = 0; i < xattrs->len; ++i) {
+    size_t len = strlen (xattrs->val[i].attrname) + 1;
+    if (size >= len) {
+      memcpy (list, xattrs->val[i].attrname, len);
+      size -= len;
+      list += len;
+      copied += len;
+    } else {
+      copied = -ERANGE;
+      break;
+    }
+  }
+
+  if (free_attrs)
+    guestfs_free_xattr_list ((struct guestfs_xattr_list *) xattrs);
+
+  return copied;
+}
+
+static int
+fg_removexattr(const char *path, const char *name)
+{
+  int r;
+
+  if (read_only) return -EROFS;
+
+  dir_cache_invalidate (path);
+
+  r = guestfs_lremovexattr (g, name, path);
+  if (r == -1)
+    return error ();
+
+  return 0;
+}
+
+static struct fuse_operations fg_operations = {
+  .getattr	= fg_getattr,
+  .access	= fg_access,
+  .readlink	= fg_readlink,
+  .readdir	= fg_readdir,
+  .mknod	= fg_mknod,
+  .mkdir	= fg_mkdir,
+  .symlink	= fg_symlink,
+  .unlink	= fg_unlink,
+  .rmdir	= fg_rmdir,
+  .rename	= fg_rename,
+  .link		= fg_link,
+  .chmod	= fg_chmod,
+  .chown	= fg_chown,
+  .truncate	= fg_truncate,
+  .utimens	= fg_utimens,
+  .open		= fg_open,
+  .read		= fg_read,
+  .write	= fg_write,
+  .statfs	= fg_statfs,
+  .release	= fg_release,
+  .fsync	= fg_fsync,
+  .setxattr	= fg_setxattr,
+  .getxattr	= fg_getxattr,
+  .listxattr	= fg_listxattr,
+  .removexattr	= fg_removexattr,
+};
+
+struct drv {
+  struct drv *next;
+  char *filename;
+};
+
+struct mp {
+  struct mp *next;
+  char *device;
+  char *mountpoint;
+};
+
+static void add_drives (struct drv *);
+static void mount_mps (struct mp *);
+
+static void __attribute__((noreturn))
+usage (int status)
+{
+  if (status != EXIT_SUCCESS)
+    fprintf (stderr, _("Try `%s --help' for more
information.\n"),
+             program_name);
+  else {
+    fprintf (stdout,
+           _("%s: FUSE module for libguestfs\n"
+             "%s lets you mount a virtual machine filesystem\n"
+             "Copyright (C) 2009 Red Hat Inc.\n"
+             "Usage:\n"
+             "  %s [--options] [-- [--FUSE-options]] mountpoint\n"
+             "Options:\n"
+             "  -a|--add image       Add image\n"
+             "  --dir-cache-timeout  Set readdir cache timeout (default 5
sec)\n"
+             "  -m|--mount dev[:mnt] Mount dev on mnt (if omitted,
/)\n"
+             "  -n|--no-sync         Don't autosync\n"
+             "  -r|--ro              Mount read-only\n"
+             "  --selinux            Enable SELinux support\n"
+             "  --trace              Trace guestfs API calls (to
stderr)\n"
+             "  -v|--verbose         Verbose messages\n"
+             "  -V|--version         Display version and exit\n"
+             "FUSE options aren't documented here.  To get a list of
options\n"
+             "supported by FUSE itself, do:\n"
+             "  %s -- --help\n"
+             ),
+             program_name, program_name, program_name, program_name);
+  }
+  exit (status);
+}
+
+int
+main (int argc, char *argv[])
+{
+  enum { HELP_OPTION = CHAR_MAX + 1 };
+
+  /* The command line arguments are broadly compatible with (a subset
+   * of) guestfish.  Thus we have to deal mainly with -a, -m and --ro.
+   */
+  static const char *options = "a:m:nrv?V";
+  static const struct option long_options[] = {
+    { "add", 1, 0, 'a' },
+    { "dir-cache-timeout", 1, 0, 0 },
+    { "help", 0, 0, HELP_OPTION },
+    { "mount", 1, 0, 'm' },
+    { "no-sync", 0, 0, 'n' },
+    { "ro", 0, 0, 'r' },
+    { "selinux", 0, 0, 0 },
+    { "trace", 0, 0, 0 },
+    { "verbose", 0, 0, 'v' },
+    { "version", 0, 0, 'V' },
+    { 0, 0, 0, 0 }
+  };
+
+  struct drv *drvs = NULL;
+  struct drv *drv;
+  struct mp *mps = NULL;
+  struct mp *mp;
+  char *p;
+  int c, i;
+  int option_index;
+  struct sigaction sa;
+
+  /* LC_ALL=C is required so we can parse error messages. */
+  setenv ("LC_ALL", "C", 1);
+
+  /* Set global program name that is not polluted with libtool artifacts.  */
+  set_program_name (argv[0]);
+
+  memset (&sa, 0, sizeof sa);
+  sa.sa_handler = SIG_IGN;
+  sa.sa_flags = SA_RESTART;
+  sigaction (SIGPIPE, &sa, NULL);
+
+  init_dir_caches ();
+
+  g = guestfs_create ();
+  if (g == NULL) {
+    fprintf (stderr, _("guestfs_create: failed to create handle\n"));
+    exit (1);
+  }
+
+  guestfs_set_autosync (g, 1);
+
+  /* If developing, add ./appliance to the path.  Note that libtools
+   * interferes with this because uninstalled guestfish is a shell
+   * script that runs the real program with an absolute path.  Detect
+   * that too.
+   *
+   * BUT if LIBGUESTFS_PATH environment variable is already set by
+   * the user, then don't override it.
+   */
+  if (getenv ("LIBGUESTFS_PATH") == NULL &&
+      argv[0] &&
+      (argv[0][0] != '/' || strstr (argv[0], "/.libs/lt-") !=
NULL))
+    guestfs_set_path (g, "appliance:" GUESTFS_DEFAULT_PATH);
+
+  for (;;) {
+    c = getopt_long (argc, argv, options, long_options, &option_index);
+    if (c == -1) break;
+
+    switch (c) {
+    case 0:			/* options which are long only */
+      if (strcmp (long_options[option_index].name,
"dir-cache-timeout") == 0)
+        dir_cache_timeout = atoi (optarg);
+      else if (strcmp (long_options[option_index].name, "selinux") ==
0)
+        guestfs_set_selinux (g, 1);
+      else if (strcmp (long_options[option_index].name, "trace") ==
0)
+        guestfs_set_trace (g, 1);
+      else {
+        fprintf (stderr, _("%s: unknown long option: %s (%d)\n"),
+                 program_name, long_options[option_index].name, option_index);
+        exit (1);
+      }
+      break;
+
+    case 'a':
+      if (access (optarg, R_OK) != 0) {
+        perror (optarg);
+        exit (1);
+      }
+      drv = malloc (sizeof (struct drv));
+      if (!drv) {
+        perror ("malloc");
+        exit (1);
+      }
+      drv->filename = optarg;
+      drv->next = drvs;
+      drvs = drv;
+      break;
+
+    case 'm':
+      mp = malloc (sizeof (struct mp));
+      if (!mp) {
+        perror ("malloc");
+        exit (1);
+      }
+      p = strchr (optarg, ':');
+      if (p) {
+        *p = '\0';
+        mp->mountpoint = p+1;
+      } else
+        mp->mountpoint = bad_cast ("/");
+      mp->device = optarg;
+      mp->next = mps;
+      mps = mp;
+      break;
+
+    case 'n':
+      guestfs_set_autosync (g, 0);
+      break;
+
+    case 'r':
+      read_only = 1;
+      break;
+
+    case 'v':
+      verbose++;
+      guestfs_set_verbose (g, verbose);
+      break;
+
+    case 'V':
+      printf ("%s %s\n", program_name, PACKAGE_VERSION);
+      exit (0);
+
+    case HELP_OPTION:
+      usage (0);
+
+    default:
+      usage (1);
+    }
+  }
+
+  /* We must have at least one -a and at least one -m. */
+  if (!drvs || !mps) {
+    fprintf (stderr,
+             _("%s: must have at least one -a and at least one -m
option\n"),
+             program_name);
+    exit (1);
+  }
+
+  add_drives (drvs);
+  if (guestfs_launch (g) == -1)
+    exit (1);
+  mount_mps (mps);
+
+  /* FUSE example does this, not clear if it's necessary, but ... */
+  if (guestfs_umask (g, 0) == -1)
+    exit (1);
+
+  /* At the last minute, remove the libguestfs error handler.  In code
+   * above this point, the default error handler has been used which
+   * sends all errors to stderr.  Now before entering FUSE itself we
+   * want to silence errors so we can convert them (see error()
+   * function above).
+   */
+  guestfs_set_error_handler (g, NULL, NULL);
+
+  /* Skip our args.  Rest are passed to FUSE. */
+  argc -= optind-1;
+  for (i = 1; i <= argc; ++i)
+    argv[i] = argv[optind+i-1];
+
+  /* Enter FUSE main loop. */
+  return fuse_main (argc, argv, &fg_operations, NULL);
+}
+
+/* List is built in reverse order, so add them in reverse order. */
+static void
+add_drives (struct drv *drv)
+{
+  int r;
+
+  if (drv) {
+    add_drives (drv->next);
+    if (!read_only)
+      r = guestfs_add_drive (g, drv->filename);
+    else
+      r = guestfs_add_drive_ro (g, drv->filename);
+    if (r == -1)
+      exit (1);
+  }
+}
+
+/* List is built in reverse order, so mount them in reverse order. */
+static void
+mount_mps (struct mp *mp)
+{
+  int r;
+
+  if (mp) {
+    mount_mps (mp->next);
+    if (!read_only)
+      r = guestfs_mount (g, mp->device, mp->mountpoint);
+    else
+      r = guestfs_mount_ro (g, mp->device, mp->mountpoint);
+    if (r == -1)
+      exit (1);
+  }
+}
diff --git a/fuse/guestmount.pod b/fuse/guestmount.pod
new file mode 100644
index 0000000..366a7f4
--- /dev/null
+++ b/fuse/guestmount.pod
@@ -0,0 +1,146 @@
+=encoding utf8
+
+=head1 NAME
+
+guestmount - Mount a guest filesystem on the host using FUSE and libguestfs
+
+=head1 SYNOPSIS
+
+ guestmount [--options] -a disk.img -m device [-- [--FUSE-options]] mountpoint
+
+=head1 DESCRIPTION
+
+The guestmount program can be used to mount virtual machine
+filesystems and other disk images on the host.  It uses libguestfs for
+access to the guest filesystem, and FUSE (the "filesystem in
+userspace") to make it appear as a mountable device.
+
+Along with other options, you have to give at least one device (I<-a>
+option) and at least one mountpoint (I<-m> option).  How this works is
+better explained in the L<guestfish(1)> manual page, or you can use
+L<virt-inspector(1)> and/or the the wrapper script
+C<guestmount-wrapper> to help you.
+
+=head1 EXAMPLES
+
+ guestmount -a windows.img -m /dev/sda1 --ro /mnt
+
+ guestmount -a linux.img -m /dev/VG/LV -m /dev/sda1:/boot --ro /mnt
+
+To get virt-inspector to do the hard work of detecting guest
+mountpoints for you:
+
+ guestmount $(virt-inspector --ro-fish MyGuest) /mnt
+
+(or use --fish if you don't want it to be a read only mount).
+
+If you want to trace the libguestfs calls but without excessive
+debugging, we recommend:
+
+ guestmount [-a ... -m ...] --trace -- -f /mnt
+
+If you want to debug the program, we recommend:
+
+ guestmount [-a ... -m ...] --trace --verbose -- -f /mnt
+
+=head1 OPTIONS
+
+FUSE itself provides additional options which are not listed on this
+page.  You can see the FUSE options available by doing:
+
+ guestmount -- --help
+
+=over 4
+
+=item B<-a image> | B<--add image>
+
+Add a block device or virtual machine image.
+
+=item B<--dir-cache-timeout N>
+
+Set the readdir cache timeout to I<N> seconds, the default being 5
+seconds.  The readdir cache [actually, there are several
+semi-independent caches] is populated after a readdir(2) call with the
+stat and extended attributes of the files in the directory, in
+anticipation that they will be requested soon after.
+
+There is also a different attribute cache implemented by FUSE
+(see the FUSE option I<-o attr_timeout>), but the FUSE cache
+does not anticipate future requests, only cache existing ones.
+
+=item B<-m dev[:mnt]> | B<--mount dev[:mnt]>
+
+Mount the named partition or logical volume on the given mountpoint
+B<in the guest> (this has nothing to do with mountpoints in the host).
+
+If the mountpoint is omitted, it defaults to C</>.  You have to mount
+something on C</>.
+
+=item B<-n> | B<--no-sync>
+
+By default, we attempt to sync the guest disk when the FUSE mountpoint
+is unmounted.  If you specify this option, then we don't attempt to
+sync the disk.  See the discussion of autosync in the L<guestfs(3)>
+manpage.
+
+=item B<-r> | B<--ro>
+
+Add devices and mount everything read-only.  Also disallow writes and
+make the disk appear read-only to FUSE.
+
+This is highly recommended if you are not going to edit the guest
+disk.  If the guest is running and this option is I<not> supplied,
+then there is a strong risk of disk corruption in the guest.  We try
+to prevent this from happening, but it is not always possible.
+
+=item B<--selinux>
+
+Enable SELinux support for the guest.
+
+=item B<--trace>
+
+Trace libguestfs calls (to stderr).
+
+=item B<-v> | B<--verbose>
+
+Enable verbose messages from underlying libguestfs.
+
+=item B<-V> | B<--version>
+
+Display the program version and exit.
+
+=back
+
+=head1 SEE ALSO
+
+L<guestfish(1)>,
+L<virt-inspector(1)>,
+L<virt-cat(1)>,
+L<virt-edit(1)>,
+L<virt-tar(1)>,
+L<guestfs(3)>,
+L<http://libguestfs.org/>,
+L<http://fuse.sf.net/>.
+
+=head1 AUTHORS
+
+Richard W.M. Jones (C<rjones at redhat dot com>)
+
+=head1 COPYRIGHT
+
+Copyright (C) 2009 Red Hat Inc.
+L<http://libguestfs.org/>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
diff --git a/m4/.gitignore b/m4/.gitignore
index d5082d7..94898a0 100644
--- a/m4/.gitignore
+++ b/m4/.gitignore
@@ -123,3 +123,5 @@ xsize.m4
 /unistd-safer.m4
 /xgetcwd.m4
 /xstrndup.m4
+/hash.m4
+/inttostr.m4
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 8c3c8f5..4d52023 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -71,6 +71,10 @@ fish/rc.c
 fish/reopen.c
 fish/tilde.c
 fish/time.c
+fuse/dircache.c
+fuse/fusexmp.c
+fuse/fusexmp_fh.c
+fuse/guestmount.c
 hivex/hivex.c
 hivex/hivexget.c
 hivex/hivexml.c
-- 
1.6.5.rc2

I should add that these patches depend on five outstanding easy fixes
which I already posted to this list but are waiting review.  These
are:

https://www.redhat.com/archives/libguestfs/2009-October/msg00116.html
  "3 small code fixes"

https://www.redhat.com/archives/libguestfs/2009-October/msg00112.html
  "appliance: Don't rebuild the appliance every time configure
runs"

https://www.redhat.com/archives/libguestfs/2009-November/msg00000.html
  "examples/to-xml.c: Don't depend on Gnulib function."

Rich.

-- 
Richard Jones, Virtualization Group, Red Hat http://people.redhat.com/~rjones
Read my programming blog: http://rwmj.wordpress.com
Fedora now supports 80 OCaml packages (the OPEN alternative to F#)
http://cocan.org/getting_started_with_ocaml_on_red_hat_and_fedora