mirrors/libguestfs
1
0
Fork 0
mirror of https://github.com/libguestfs/libguestfs.git synced 2026-03-21 22:53:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

FUSE filesystem support.

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

Note: file writes (ie. write(2) system call) is not yet implemented.

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).
This commit is contained in:
Richard Jones
2009-10-30 16:13:13 +00:00
parent 08c9bf5e22
commit 429de22541
14 changed files with 1919 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@@ -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

3
HACKING
View File

@@ -83,6 +83,9 @@ examples/
fish/
Guestfish (the command-line program / shell)
fuse/
FUSE (userspace filesystem) built on top of libguestfs.
haskell/
Haskell bindings.

5
Makefile.am
View File

@@ -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 \

2
README
View File

@@ -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

33
TODO
View File

@@ -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
--------
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.
The API needs more test coverage, particularly lesser-used system
calls.
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
--------

2
bootstrap
View File

@@ -63,6 +63,8 @@ closeout
gitlog-to-changelog
gnu-make
gnumakefile
hash
hash-pjw
ignore-value
maintainer-makefile
manywarnings

11
configure.ac
View File

@@ -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
@@ -726,7 +733,8 @@ AC_CONFIG_FILES([Makefile
libguestfs.pc
gnulib/lib/Makefile
gnulib/tests/Makefile
hivex/Makefile
hivex/Makefile
fuse/Makefile
ocaml/META perl/Makefile.PL])
AC_OUTPUT
@@ -756,6 +764,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."

62
fuse/Makefile.am Normal file
View File

@@ -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

408
fuse/dircache.c Normal file
View File

@@ -0,0 +1,408 @@
/* 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@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);
}
}
void
free_dir_caches (void)
{
hash_free (lsc_ht);
hash_free (xac_ht);
hash_free (rlc_ht);
}
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);
}

44
fuse/dircache.h Normal file
View File

@@ -0,0 +1,44 @@
/* 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@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 free_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 */

1163
fuse/guestmount.c Normal file
View File

File diff suppressed because it is too large Load Diff

205
fuse/guestmount.pod Normal file
View File

@@ -0,0 +1,205 @@
=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 [--ro] mountpoint
=head1 WARNING
You must I<not> use C<guestmount> in read-write mode on live virtual
machines. If you do this, you risk disk corruption in the VM.
=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.
FUSE lets you mount filesystems as non-root. The mountpoint must be
owned by you, and the filesystem will not be visible to any other
users unless you make certain global configuration changes to
C</etc/fuse.conf>. To unmount the filesystem, use the C<fusermount -u>
command.
=head1 EXAMPLES
For a typical Windows guest which has its main filesystem on the
first partition:
guestmount -a windows.img -m /dev/sda1 --ro /mnt
For a typical Linux guest which has a /boot filesystem on the first
partition, and the root filesystem on a logical volume:
guestmount -a linux.img -m /dev/VG/LV -m /dev/sda1:/boot --ro /mnt
To get L<virt-inspector(1)> 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). The
option is called I<--ro-fish> or I<--fish> because these parameters
are compatible with L<guestfish(1)>.
If you want to trace the libguestfs calls but without excessive
debugging, we recommend:
guestmount [-a ... -m ...] --trace /mnt
If you want to debug the program, we recommend:
guestmount [-a ... -m ...] --trace --verbose /mnt
=head1 OPTIONS
=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 60
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<--fuse-help>
Display help on special FUSE options (see I<-o> below).
=item B<--help>
Display brief help and exit.
=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<-o option> | B<--option option>
Pass extra options to FUSE.
To get a list of all the extra options supported by FUSE, use the
command below. Note that only the FUSE I<-o> options can be passed,
and only some of them are a good idea.
guestmount --fuse-help
Some potentially useful FUSE options:
=over 4
=item B<-o allow_other>
Allow other users to see the filesystem.
=item B<-o attr_timeout=N>
Enable attribute caching by FUSE, and set the timeout to I<N> seconds.
=item B<-o kernel_cache>
Allow the kernel to cache files (reduces the number of reads
that have to go through the L<guestfs(3)> API). This is generally
a good idea if you can afford the extra memory usage.
=item B<-o uid=N> B<-o gid=N>
Use these options to map all UIDs and GIDs inside the guest filesystem
to the chosen values.
=back
=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).
This also stops the daemon from forking into the background.
=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.

2
m4/.gitignore vendored
View File

@@ -123,3 +123,5 @@ xsize.m4
/unistd-safer.m4
/xgetcwd.m4
/xstrndup.m4
/hash.m4
/inttostr.m4

2
po/POTFILES.in
View File

@@ -71,6 +71,8 @@ fish/rc.c
fish/reopen.c
fish/tilde.c
fish/time.c
fuse/dircache.c
fuse/guestmount.c
hivex/hivex.c
hivex/hivexget.c
hivex/hivexml.c