guestfish - the libguestfs filesystem interactive shell
guestfish [--options] [commands]
guestfish -i libvirt-domain
guestfish -i disk-image(s)
Create a new /etc/motd file in a guest:
guestfish <<_EOF_ add disk.img run mount /dev/VolGroup00/LogVol00 / write_file /etc/motd "Hello users" 0 _EOF_
List the LVs in a guest:
guestfish <<_EOF_ add disk.img run lvs _EOF_
List the LVM PVs in a guest image:
guestfish add disk.img : run : pvs
Remove /boot/grub/menu.lst (in reality not such a great idea):
guestfish --add disk.img \ --mount /dev/VolGroup00/LogVol00 \ --mount /dev/sda1:/boot \ rm /boot/grub/menu.lst
$ guestfish
Welcome to guestfish, the libguestfs filesystem interactive shell for editing virtual machine filesystems.
Type: 'help' for help with commands
'quit' to quit the shell
><fs> help
#!/usr/bin/guestfish -f alloc /tmp/output.img 10M run sfdisk /dev/sda 0 0 0 , mkfs ext2 /dev/sda1
eval `guestfish --listen` guestfish --remote cmd
Guestfish is a shell and command-line tool for examining and modifying virtual machine filesystems. It uses libguestfs and exposes all of the functionality of the guestfs API, see guestfs(3).
Displays general help on options.
Lists all available guestfish commands.
Displays detailed help on a single command cmd.
Add a block device or virtual machine image to the shell.
Don't tab-complete paths on the guest filesystem. It is useful to be able to hit the tab key to complete paths on the guest filesystem, but this causes extra "hidden" guestfs calls to be made, so this option is here to allow this feature to be disabled.
Read commands from file. To write pure guestfish
scripts, use:
#!/usr/bin/guestfish -f
Run virt-inspector on the named libvirt domain or list of disk images. If virt-inspector is available and if it can identify the domain or disk images, then partitions will be mounted correctly at start-up.
Typical usage is either:
guestfish -i myguest
(for an inactive libvirt domain called myguest), or:
guestfish --ro -i myguest
(for active domains, readonly), or specify the block device directly:
guestfish -i /dev/Guests/MyGuest
You cannot use -a, -m, --listen, --remote or --selinux in conjunction with this option, and options other than --ro might not behave correctly.
See also: virt-inspector(1).
Fork into the background and listen for remote commands. See section REMOTE CONTROL GUESTFISH OVER A SOCKET below.
Mount the named partition or logical volume on the given mountpoint.
If the mountpoint is omitted, it defaults to /.
You have to mount something on / before most commands will work.
If any -m or --mount options are given, the guest is
automatically launched.
Disable autosync. This is enabled by default. See the discussion of autosync in the guestfs(3) manpage.
Send remote commands to $GUESTFISH_PID or pid. See section
REMOTE CONTROL GUESTFISH OVER A SOCKET below.
This changes the -m option so that mounts are done read-only
(see guestfs_mount_ro in the guestfs(3) manpage).
Enable SELinux support for the guest. See guestfs(3)/SELINUX.
Enable very verbose messages. This is particularly useful if you find a bug.
Display the guestfish / libguestfs version number and exit.
Echo each command before executing it.
Any additional (non-option) arguments are treated as commands to execute.
Commands to execute should be separated by a colon (:), where the
colon is a separate parameter. Thus:
guestfish cmd [args...] : cmd [args...] : cmd [args...] ...
If there are no additional arguments, then we enter a shell, either an interactive shell with a prompt (if the input is a terminal) or a non-interactive shell.
In either command line mode or non-interactive shell, the first command that gives an error causes the whole shell to exit. In interactive mode (with a prompt) if a command fails, you can continue to enter commands.
As with guestfs(3), you must first configure your guest by adding disks, then launch it, then mount any disks you need, and finally issue actions/commands. So the general order of the day is:
add or -a/--add
launch (aka run)
mount or -m/--mount
any other commands
run is a synonym for launch. You must launch (or run)
your guest before mounting or performing any other commands.
The only exception is that if the -m or --mount option was
given, the guest is automatically run for you (simply because
guestfish can't mount the disks you asked for without doing this).
You can quote ordinary parameters using either single or double quotes. For example:
add "file with a space.img"
rm '/file name'
rm '/"'
A few commands require a list of strings to be passed. For these, use a whitespace-separated list, enclosed in quotes. Strings containing whitespace to be passed through must be enclosed in single quotes. A literal single quote must be escaped with a backslash.
vgcreate VG "/dev/sda1 /dev/sdb1" command "/bin/echo 'foo bar'" command "/bin/echo \'foo\'"
Neither guestfish nor the underlying guestfs API performs wildcard expansion (globbing) by default. So for example the following will not do what you expect:
rm-rf /home/*
Assuming you don't have a directory literally called /home/*
then the above command will return an error.
To perform wildcard expansion, use the glob command.
glob rm-rf /home/*
runs rm-rf on each path that matches (ie. potentially running
the command many times), equivalent to:
rm-rf /home/jim rm-rf /home/joe rm-rf /home/mary
glob only works on simple guest paths and not on device names.
If you have several parameters, each containing a wildcard, then glob will perform a cartesian product.
Any line which starts with a # character is treated as a comment and ignored. The # can optionally be preceeded by whitespace, but not by a command. For example:
# this is a comment
# this is a comment
foo # NOT a comment
Blank lines are also ignored.
Any line which starts with a ! character is treated as a command
sent to the local shell (/bin/sh or whatever system(3) uses).
For example:
!mkdir local tgz-out /remote local/remote-data.tar.gz
will create a directory local on the host, and then export
the contents of /remote on the mounted filesystem to
local/remote-data.tar.gz. (See tgz-out).
Use command <space> | command to pipe the output of the
first command (a guestfish command) to the second command (any host
command). For example:
cat /etc/passwd | awk -F: '$3 == 0 { print }'
(where cat is the guestfish cat command, but awk is the host awk
program). The above command would list all accounts in the guest
filesystem which have UID 0, ie. root accounts including backdoors.
Other examples:
hexdump /bin/ls | head list-devices | tail -1
The space before the pipe symbol is required, any space after the pipe symbol is optional. Everything after the pipe symbol is just passed straight to the host shell, so it can contain redirections, globs and anything else that makes sense on the host side.
To use a literal argument which begins with a pipe symbol, you have to quote it, eg:
echo "|"
If a parameter starts with the character ~ then the tilde may be
expanded as a home directory path (either ~ for the current user's
home directory, or ~user for another user).
Note that home directory expansion happens for users known on the host, not in the guest filesystem.
To use a literal argument which begins with a tilde, you have to quote it, eg:
echo "~"
If a path is prefixed with win: then you can use Windows-style
paths (with some limitations). The following commands are equivalent:
file /WINDOWS/system32/config/system.LOG
file win:/windows/system32/config/system.log
file win:\windows\system32\config\system.log
file WIN:C:\Windows\SYSTEM32\conFIG\SYSTEM.LOG
This syntax implicitly calls case-sensitive-path (q.v.) so it also
handles case insensitivity like Windows would. This only works in
argument positions that expect a path.
By default, guestfish will ignore any errors when in interactive mode (ie. taking commands from a human over a tty), and will exit on the first error in non-interactive mode (scripts, commands given on the command line).
If you prefix a command with a - character, then that command will not cause guestfish to exit, even if that (one) command returns an error.
Guestfish can be remote-controlled over a socket. This is useful particularly in shell scripts where you want to make several different changes to a filesystem, but you don't want the overhead of starting up a guestfish process each time.
Start a guestfish server process using:
eval `guestfish --listen`
and then send it commands by doing:
guestfish --remote cmd [...]
To cause the server to exit, send it the exit command:
guestfish --remote exit
Note that the server will normally exit if there is an error in a command. You can change this in the usual way. See section EXIT ON ERROR BEHAVIOUR.
The eval statement sets the environment variable $GUESTFISH_PID,
which is how the --remote option knows where to send the commands.
You can have several guestfish listener processes running using:
eval `guestfish --listen` pid1=$GUESTFISH_PID eval `guestfish --listen` pid2=$GUESTFISH_PID ... guestfish --remote=$pid1 cmd guestfish --remote=$pid2 cmd
Remote control happens over a Unix domain socket called
/tmp/.guestfish-$UID/socket-$PID, where $UID is the effective
user ID of the process, and $PID is the process ID of the server.
Guestfish client and server versions must match exactly.
The commands in this section are guestfish convenience commands, in other words, they are not part of the guestfs(3) API.
alloc filename size
This creates an empty (zeroed) file of the given size, and then adds so it can be further examined.
For more advanced image creation, see qemu-img(1) utility.
Size can be specified (where nn means a number):
nn or nnK or nnKBnumber of kilobytes, eg: 1440 = standard 3.5in floppy
nnM or nnMBnumber of megabytes
nnG or nnGBnumber of gigabytes
nnsectsnumber of 512 byte sectors
echo [params ...]
This echos the parameters to the terminal.
edit filename
This is used to edit a file. It downloads the file, edits it locally using your editor, then uploads the result.
The editor is $EDITOR. However if you use the alternate
commands vi or emacs you will get those corresponding
editors.
NOTE: This will not work reliably for large files (> 2 MB) or binary files containing \0 bytes.
glob command args...
Expand wildcards in any paths in the args list, and run command
repeatedly on each matching path.
See section WILDCARDS AND GLOBBING.
help help cmd
Without any parameter, this lists all commands. With a cmd
parameter, this displays detailed help for a command.
lcd directory
Change the local directory, ie. the current directory of guestfish itself.
Note that !cd won't do what you might expect.
more filename
less filename
This is used to view a file.
The default viewer is $PAGER. However if you use the alternate
command less you will get the less command specifically.
NOTE: This will not work reliably for large files (> 2 MB) or binary files containing \0 bytes.
This exits guestfish. You can also use ^D key.
reopen
Close and reopen the libguestfs handle. It is not necessary to use this normally, because the handle is closed properly when guestfish exits. However this is occasionally useful for testing.
time command args...
Run the command as usual, but print the elapsed time afterwards. This can be useful for benchmarking operations.
add-cdrom filename
This function adds a virtual CD-ROM disk image to the guest.
This is equivalent to the qemu parameter -cdrom filename.
Note that this call checks for the existence of filename. This
stops you from specifying other types of drive which are supported
by qemu such as nbd: and http: URLs. To specify those, use
the general config call instead.
add-drive filename
This function adds a virtual machine disk image filename to the
guest. The first time you call this function, the disk appears as IDE
disk 0 (/dev/sda) in the guest, the second time as /dev/sdb, and
so on.
You don't necessarily need to be root when using libguestfs. However you obviously do need sufficient permissions to access the filename for whatever operations you want to perform (ie. read access if you just want to read the image or write access if you want to modify the image).
This is equivalent to the qemu parameter
-drive file=filename,cache=off,if=....
cache=off is omitted in cases where it is not supported by
the underlying filesystem.
Note that this call checks for the existence of filename. This
stops you from specifying other types of drive which are supported
by qemu such as nbd: and http: URLs. To specify those, use
the general config call instead.
add-drive-ro filename
This adds a drive in snapshot mode, making it effectively read-only.
Note that writes to the device are allowed, and will be seen for the duration of the guestfs handle, but they are written to a temporary file which is discarded as soon as the guestfs handle is closed. We don't currently have any method to enable changes to be committed, although qemu can support this.
This is equivalent to the qemu parameter
-drive file=filename,snapshot=on,if=....
Note that this call checks for the existence of filename. This
stops you from specifying other types of drive which are supported
by qemu such as nbd: and http: URLs. To specify those, use
the general config call instead.
aug-close
Close the current Augeas handle and free up any resources
used by it. After calling this, you have to call
aug-init again before you can use any other
Augeas functions.
aug-defnode name expr val
Defines a variable name whose value is the result of
evaluating expr.
If expr evaluates to an empty nodeset, a node is created,
equivalent to calling aug-set expr, value.
name will be the nodeset containing that single node.
On success this returns a pair containing the number of nodes in the nodeset, and a boolean flag if a node was created.
aug-defvar name expr
Defines an Augeas variable name whose value is the result
of evaluating expr. If expr is NULL, then name is
undefined.
On success this returns the number of nodes in expr, or
0 if expr evaluates to something which is not a nodeset.
aug-get augpath
Look up the value associated with path. If path
matches exactly one node, the value is returned.
aug-init root flags
Create a new Augeas handle for editing configuration files. If there was any previous Augeas handle associated with this guestfs session, then it is closed.
You must call this before using any other aug-*
commands.
root is the filesystem root. root must not be NULL,
use / instead.
The flags are the same as the flags defined in <augeas.h>, the logical or of the following integers:
AUG_SAVE_BACKUP = 1Keep the original file with a .augsave extension.
AUG_SAVE_NEWFILE = 2Save changes into a file with extension .augnew, and
do not overwrite original. Overrides AUG_SAVE_BACKUP.
AUG_TYPE_CHECK = 4Typecheck lenses (can be expensive).
AUG_NO_STDINC = 8Do not use standard load path for modules.
AUG_SAVE_NOOP = 16Make save a no-op, just record what would have been changed.
AUG_NO_LOAD = 32Do not load the tree in aug-init.
To close the handle, you can call aug-close.
To find out more about Augeas, see http://augeas.net/.
aug-insert augpath label true|false
Create a new sibling label for path, inserting it into
the tree before or after path (depending on the boolean
flag before).
path must match exactly one existing node in the tree, and
label must be a label, ie. not contain /, * or end
with a bracketed index [N].
aug-load
Load files into the tree.
See aug_load in the Augeas documentation for the full gory
details.
aug-ls augpath
This is just a shortcut for listing aug-match
path/* and sorting the resulting nodes into alphabetical order.
aug-match augpath
Returns a list of paths which match the path expression path.
The returned paths are sufficiently qualified so that they match
exactly one node in the current tree.
aug-mv src dest
Move the node src to dest. src must match exactly
one node. dest is overwritten if it exists.
aug-rm augpath
Remove path and all of its children.
On success this returns the number of entries which were removed.
aug-save
This writes all pending changes to disk.
The flags which were passed to aug-init affect exactly
how files are saved.
aug-set augpath val
Set the value associated with path to value.
blockdev-flushbufs device
This tells the kernel to flush internal buffers associated
with device.
This uses the blockdev(8) command.
blockdev-getbsz device
This returns the block size of a device.
(Note this is different from both size in blocks and filesystem block size).
This uses the blockdev(8) command.
blockdev-getro device
Returns a boolean indicating if the block device is read-only (true if read-only, false if not).
This uses the blockdev(8) command.
blockdev-getsize64 device
This returns the size of the device in bytes.
See also blockdev-getsz.
This uses the blockdev(8) command.
blockdev-getss device
This returns the size of sectors on a block device. Usually 512, but can be larger for modern devices.
(Note, this is not the size in sectors, use blockdev-getsz
for that).
This uses the blockdev(8) command.
blockdev-getsz device
This returns the size of the device in units of 512-byte sectors (even if the sectorsize isn't 512 bytes ... weird).
See also blockdev-getss for the real sector size of
the device, and blockdev-getsize64 for the more
useful size in bytes.
This uses the blockdev(8) command.
blockdev-rereadpt device
Reread the partition table on device.
This uses the blockdev(8) command.
blockdev-setbsz device blocksize
This sets the block size of a device.
(Note this is different from both size in blocks and filesystem block size).
This uses the blockdev(8) command.
blockdev-setro device
Sets the block device named device to read-only.
This uses the blockdev(8) command.
blockdev-setrw device
Sets the block device named device to read-write.
This uses the blockdev(8) command.
case-sensitive-path path
This can be used to resolve case insensitive paths on a filesystem which is case sensitive. The use case is to resolve paths which you have read from Windows configuration files or the Windows Registry, to the true path.
The command handles a peculiarity of the Linux ntfs-3g filesystem driver (and probably others), which is that although the underlying filesystem is case-insensitive, the driver exports the filesystem to Linux as case-sensitive.
One consequence of this is that special directories such
as c:\windows may appear as /WINDOWS or /windows
(or other things) depending on the precise details of how
they were created. In Windows itself this would not be
a problem.
Bug or feature? You decide: http://www.tuxera.com/community/ntfs-3g-faq/#posixfilenames1
This function resolves the true case of each element in the path and returns the case-sensitive path.
Thus case-sensitive-path ("/Windows/System32")
might return "/WINDOWS/system32" (the exact return value
would depend on details of how the directories were originally
created under Windows).
Note: This function does not handle drive names, backslashes etc.
See also realpath.
cat path
Return the contents of the file named path.
Note that this function cannot correctly handle binary files
(specifically, files containing \0 character which is treated
as end of string). For those you need to use the read-file
or download functions which have a more complex interface.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
checksum csumtype path
This call computes the MD5, SHAx or CRC checksum of the
file named path.
The type of checksum to compute is given by the csumtype
parameter which must have one of the following values:
crcCompute the cyclic redundancy check (CRC) specified by POSIX
for the cksum command.
md5Compute the MD5 hash (using the md5sum program).
sha1Compute the SHA1 hash (using the sha1sum program).
sha224Compute the SHA224 hash (using the sha224sum program).
sha256Compute the SHA256 hash (using the sha256sum program).
sha384Compute the SHA384 hash (using the sha384sum program).
sha512Compute the SHA512 hash (using the sha512sum program).
The checksum is returned as a printable string.
chmod mode path
Change the mode (permissions) of path to mode. Only
numeric modes are supported.
chown owner group path
Change the file owner to owner and group to group.
Only numeric uid and gid are supported. If you want to use names, you will need to locate and parse the password file yourself (Augeas support makes this relatively easy).
command 'arguments ...'
This call runs a command from the guest filesystem. The filesystem must be mounted, and must contain a compatible operating system (ie. something Linux, with the same or compatible processor architecture).
The single parameter is an argv-style list of arguments.
The first element is the name of the program to run.
Subsequent elements are parameters. The list must be
non-empty (ie. must contain a program name). Note that
the command runs directly, and is not invoked via
the shell (see sh).
The return value is anything printed to stdout by the command.
If the command returns a non-zero exit status, then this function returns an error message. The error message string is the content of stderr from the command.
The $PATH environment variable will contain at least
/usr/bin and /bin. If you require a program from
another location, you should provide the full path in the
first parameter.
Shared libraries and data files required by the program must be available on filesystems which are mounted in the correct places. It is the caller's responsibility to ensure all filesystems that are needed are mounted at the right locations.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
command-lines 'arguments ...'
This is the same as command, but splits the
result into a list of lines.
See also: sh-lines
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
config qemuparam qemuvalue
This can be used to add arbitrary qemu command line parameters
of the form -param value. Actually it's not quite arbitrary - we
prevent you from setting some parameters which would interfere with
parameters that we use.
The first character of param string must be a - (dash).
value can be NULL.
cp src dest
This copies a file from src to dest where dest is
either a destination filename or destination directory.
cp-a src dest
This copies a file or directory from src to dest
recursively using the cp -a command.
debug subcmd 'extraargs ...'
The debug command exposes some internals of
guestfsd (the guestfs daemon) that runs inside the
qemu subprocess.
There is no comprehensive help for this command. You have
to look at the file daemon/debug.c in the libguestfs source
to find out what you can do.
df
This command runs the df command to report disk space used.
This command is mostly useful for interactive sessions. It
is not intended that you try to parse the output string.
Use statvfs from programs.
df-h
This command runs the df -h command to report disk space used
in human-readable format.
This command is mostly useful for interactive sessions. It
is not intended that you try to parse the output string.
Use statvfs from programs.
dmesg
This returns the kernel messages (dmesg output) from
the guest kernel. This is sometimes useful for extended
debugging of problems.
Another way to get the same information is to enable
verbose messages with set-verbose or by setting
the environment variable LIBGUESTFS_DEBUG=1 before
running the program.
download remotefilename (filename|-)
Download file remotefilename and save it as filename
on the local machine.
filename can also be a named pipe.
See also upload, cat.
Use - instead of a filename to read/write from stdin/stdout.
drop-caches whattodrop
This instructs the guest kernel to drop its page cache,
and/or dentries and inode caches. The parameter whattodrop
tells the kernel what precisely to drop, see
http://linux-mm.org/Drop_Caches
Setting whattodrop to 3 should drop everything.
This automatically calls sync(2) before the operation, so that the maximum guest memory is freed.
du path
This command runs the du -s command to estimate file space
usage for path.
path can be a file or a directory. If path is a directory
then the estimate includes the contents of the directory and all
subdirectories (recursively).
The result is the estimated size in kilobytes (ie. units of 1024 bytes).
e2fsck-f device
This runs e2fsck -p -f device, ie. runs the ext2/ext3
filesystem checker on device, noninteractively (-p),
even if the filesystem appears to be clean (-f).
This command is only needed because of resize2fs
(q.v.). Normally you should use fsck.
echo-daemon 'words ...'
This command concatenate the list of words passed with single spaces between
them and returns the resulting string.
You can use this command to test the connection through to the daemon.
See also ping-daemon.
egrep regex path
This calls the external egrep program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
egrepi regex path
This calls the external egrep -i program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
equal file1 file2
This compares the two files file1 and file2 and returns
true if their content is exactly equal, or false otherwise.
The external cmp(1) program is used for the comparison.
exists path
This returns true if and only if there is a file, directory
(or anything) with the given path name.
See also is-file, is-dir, stat.
fallocate path len
This command preallocates a file (containing zero bytes) named
path of size len bytes. If the file exists already, it
is overwritten.
Do not confuse this with the guestfish-specific
alloc command which allocates a file in the host and
attaches it as a device.
fgrep pattern path
This calls the external fgrep program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
fgrepi pattern path
This calls the external fgrep -i program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
file path
This call uses the standard file(1) command to determine the type or contents of the file. This also works on devices, for example to find out whether a partition contains a filesystem.
This call will also transparently look inside various types of compressed file.
The exact command which runs is file -zbsL path. Note in
particular that the filename is not prepended to the output
(the -b option).
find directory
This command lists out all files and directories, recursively,
starting at directory. It is essentially equivalent to
running the shell command find directory -print but some
post-processing happens on the output, described below.
This returns a list of strings without any prefix. Thus if the directory structure was:
/tmp/a /tmp/b /tmp/c/d
then the returned list from find /tmp would be
4 elements:
a b c c/d
If directory is not a directory, then this command returns
an error.
The returned list is sorted.
See also find0.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
find0 directory (files|-)
This command lists out all files and directories, recursively,
starting at directory, placing the resulting list in the
external file called files.
This command works the same way as find with the
following exceptions:
The resulting list is written to an external file.
Items (filenames) in the result are separated
by \0 characters. See find(1) option -print0.
This command is not limited in the number of names that it can return.
The result list is not sorted.
Use - instead of a filename to read/write from stdin/stdout.
fsck fstype device
This runs the filesystem checker (fsck) on device which
should have filesystem type fstype.
The returned integer is the status. See fsck(8) for the
list of status codes from fsck.
Notes:
Multiple status codes can be summed together.
A non-zero return code can mean "success", for example if errors have been corrected on the filesystem.
Checking or repairing NTFS volumes is not supported (by linux-ntfs).
This command is entirely equivalent to running fsck -a -t fstype device.
get-append
Return the additional kernel options which are added to the guest kernel command line.
If NULL then no options are added.
get-autosync
Get the autosync flag.
get-direct
Return the direct appliance mode flag.
get-e2label device
This returns the ext2/3/4 filesystem label of the filesystem on
device.
get-e2uuid device
This returns the ext2/3/4 filesystem UUID of the filesystem on
device.
get-memsize
This gets the memory size in megabytes allocated to the qemu subprocess.
If set-memsize was not called
on this handle, and if LIBGUESTFS_MEMSIZE was not set,
then this returns the compiled-in default value for memsize.
For more information on the architecture of libguestfs, see guestfs(3).
get-path
Return the current search path.
This is always non-NULL. If it wasn't set already, then this will return the default path.
get-pid
Return the process ID of the qemu subprocess. If there is no qemu subprocess, then this will return an error.
This is an internal call used for debugging and testing.
get-qemu
Return the current qemu binary.
This is always non-NULL. If it wasn't set already, then this will return the default qemu binary name.
get-selinux
This returns the current setting of the selinux flag which
is passed to the appliance at boot time. See set-selinux.
For more information on the architecture of libguestfs, see guestfs(3).
get-state
This returns the current state as an opaque integer. This is only useful for printing debug and internal error messages.
For more information on states, see guestfs(3).
get-trace
Return the command trace flag.
get-verbose
This returns the verbose messages flag.
getcon
This gets the SELinux security context of the daemon.
See the documentation about SELINUX in guestfs(3),
and setcon
getxattrs path
This call lists the extended attributes of the file or directory
path.
At the system call level, this is a combination of the listxattr(2) and getxattr(2) calls.
See also: lgetxattrs, attr(5).
glob-expand pattern
This command searches for all the pathnames matching
pattern according to the wildcard expansion rules
used by the shell.
If no paths match, then this returns an empty list (note: not an error).
It is just a wrapper around the C glob(3) function
with flags GLOB_MARK|GLOB_BRACE.
See that manual page for more details.
grep regex path
This calls the external grep program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
grepi regex path
This calls the external grep -i program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
grub-install root device
This command installs GRUB (the Grand Unified Bootloader) on
device, with the root directory being root.
head path
This command returns up to the first 10 lines of a file as a list of strings.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
head-n nrlines path
If the parameter nrlines is a positive number, this returns the first
nrlines lines of the file path.
If the parameter nrlines is a negative number, this returns lines
from the file path, excluding the last nrlines lines.
If the parameter nrlines is zero, this returns an empty list.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
hexdump path
This runs hexdump -C on the given path. The result is
the human-readable, canonical hex dump of the file.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
initrd-list path
This command lists out files contained in an initrd.
The files are listed without any initial / character. The
files are listed in the order they appear (not necessarily
alphabetical). Directory names are listed as separate items.
Old Linux kernels (2.4 and earlier) used a compressed ext2 filesystem as initrd. We only support the newer initramfs format (compressed cpio files).
inotify-add-watch path mask
Watch path for the events listed in mask.
Note that if path is a directory then events within that
directory are watched, but this does not happen recursively
(in subdirectories).
Note for non-C or non-Linux callers: the inotify events are
defined by the Linux kernel ABI and are listed in
/usr/include/sys/inotify.h.
inotify-close
This closes the inotify handle which was previously opened by inotify_init. It removes all watches, throws away any pending events, and deallocates all resources.
inotify-files
This function is a helpful wrapper around inotify-read
which just returns a list of pathnames of objects that were
touched. The returned pathnames are sorted and deduplicated.
inotify-init maxevents
This command creates a new inotify handle. The inotify subsystem can be used to notify events which happen to objects in the guest filesystem.
maxevents is the maximum number of events which will be
queued up between calls to inotify-read or
inotify-files.
If this is passed as 0, then the kernel (or previously set)
default is used. For Linux 2.6.29 the default was 16384 events.
Beyond this limit, the kernel throws away events, but records
the fact that it threw them away by setting a flag
IN_Q_OVERFLOW in the returned structure list (see
inotify-read).
Before any events are generated, you have to add some
watches to the internal watch list. See:
inotify-add-watch,
inotify-rm-watch and
inotify-watch-all.
Queued up events should be read periodically by calling
inotify-read
(or inotify-files which is just a helpful
wrapper around inotify-read). If you don't
read the events out often enough then you risk the internal
queue overflowing.
The handle should be closed after use by calling
inotify-close. This also removes any
watches automatically.
See also inotify(7) for an overview of the inotify interface as exposed by the Linux kernel, which is roughly what we expose via libguestfs. Note that there is one global inotify handle per libguestfs instance.
inotify-read
Return the complete queue of events that have happened since the previous read call.
If no events have happened, this returns an empty list.
Note: In order to make sure that all events have been read, you must call this function repeatedly until it returns an empty list. The reason is that the call will read events up to the maximum appliance-to-host message size and leave remaining events in the queue.
inotify-rm-watch wd
Remove a previously defined inotify watch.
See inotify-add-watch.
is-busy
This returns true iff this handle is busy processing a command
(in the BUSY state).
For more information on states, see guestfs(3).
is-config
This returns true iff this handle is being configured
(in the CONFIG state).
For more information on states, see guestfs(3).
is-dir path
This returns true if and only if there is a directory
with the given path name. Note that it returns false for
other objects like files.
See also stat.
is-file path
This returns true if and only if there is a file
with the given path name. Note that it returns false for
other objects like directories.
See also stat.
is-launching
This returns true iff this handle is launching the subprocess
(in the LAUNCHING state).
For more information on states, see guestfs(3).
is-ready
This returns true iff this handle is ready to accept commands
(in the READY state).
For more information on states, see guestfs(3).
kill-subprocess
This kills the qemu subprocess. You should never need to call this.
launch
Internally libguestfs is implemented by running a virtual machine using qemu(1).
You should call this after configuring the handle (eg. adding drives) but before performing any actions.
lgetxattrs path
This is the same as getxattrs, but if path
is a symbolic link, then it returns the extended attributes
of the link itself.
list-devices
List all the block devices.
The full block device names are returned, eg. /dev/sda
list-partitions
List all the partitions detected on all block devices.
The full partition device names are returned, eg. /dev/sda1
This does not return logical volumes. For that you will need to
call lvs.
ll directory
List the files in directory (relative to the root directory,
there is no cwd) in the format of 'ls -la'.
This command is mostly useful for interactive sessions. It is not intended that you try to parse the output string.
ln target linkname
This command creates a hard link using the ln command.
ln-f target linkname
This command creates a hard link using the ln -f command.
The -f option removes the link (linkname) if it exists already.
ln-s target linkname
This command creates a symbolic link using the ln -s command.
ln-sf target linkname
This command creates a symbolic link using the ln -sf command,
The -f option removes the link (linkname) if it exists already.
lremovexattr xattr path
This is the same as removexattr, but if path
is a symbolic link, then it removes an extended attribute
of the link itself.
ls directory
List the files in directory (relative to the root directory,
there is no cwd). The '.' and '..' entries are not returned, but
hidden files are shown.
This command is mostly useful for interactive sessions. Programs
should probably use readdir instead.
lsetxattr xattr val vallen path
This is the same as setxattr, but if path
is a symbolic link, then it sets an extended attribute
of the link itself.
lstat path
Returns file information for the given path.
This is the same as stat except that if path
is a symbolic link, then the link is stat-ed, not the file it
refers to.
This is the same as the lstat(2) system call.
lvcreate logvol volgroup mbytes
This creates an LVM volume group called logvol
on the volume group volgroup, with size megabytes.
lvm-remove-all
This command removes all LVM logical volumes, volume groups and physical volumes.
This command is dangerous. Without careful use you can easily destroy all your data.
lvremove device
Remove an LVM logical volume device, where device is
the path to the LV, such as /dev/VG/LV.
You can also remove all LVs in a volume group by specifying
the VG name, /dev/VG.
lvresize device mbytes
This resizes (expands or shrinks) an existing LVM logical
volume to mbytes. When reducing, data in the reduced part
is lost.
lvs
List all the logical volumes detected. This is the equivalent of the lvs(8) command.
This returns a list of the logical volume device names
(eg. /dev/VolGroup00/LogVol00).
See also lvs-full.
lvs-full
List all the logical volumes detected. This is the equivalent of the lvs(8) command. The "full" version includes all fields.
mkdir path
Create a directory named path.
mkdir-p path
Create a directory named path, creating any parent directories
as necessary. This is like the mkdir -p shell command.
mkdtemp template
This command creates a temporary directory. The
template parameter should be a full pathname for the
temporary directory name with the final six characters being
"XXXXXX".
For example: "/tmp/myprogXXXXXX" or "/Temp/myprogXXXXXX", the second one being suitable for Windows filesystems.
The name of the temporary directory that was created is returned.
The temporary directory is created with mode 0700 and is owned by root.
The caller is responsible for deleting the temporary directory and its contents after use.
See also: mkdtemp(3)
mke2fs-J fstype blocksize device journal
This creates an ext2/3/4 filesystem on device with
an external journal on journal. It is equivalent
to the command:
mke2fs -t fstype -b blocksize -J device=<journal> <device>
See also mke2journal.
mke2fs-JL fstype blocksize device label
This creates an ext2/3/4 filesystem on device with
an external journal on the journal labeled label.
See also mke2journal-L.
mke2fs-JU fstype blocksize device uuid
This creates an ext2/3/4 filesystem on device with
an external journal on the journal with UUID uuid.
See also mke2journal-U.
mke2journal blocksize device
This creates an ext2 external journal on device. It is equivalent
to the command:
mke2fs -O journal_dev -b blocksize device
mke2journal-L blocksize label device
This creates an ext2 external journal on device with label label.
mke2journal-U blocksize uuid device
This creates an ext2 external journal on device with UUID uuid.
mkfifo mode path
This call creates a FIFO (named pipe) called path with
mode mode. It is just a convenient wrapper around
mknod.
mkfs fstype device
This creates a filesystem on device (usually a partition
or LVM logical volume). The filesystem type is fstype, for
example ext3.
mkfs-b fstype blocksize device
This call is similar to mkfs, but it allows you to
control the block size of the resulting filesystem. Supported
block sizes depend on the filesystem type, but typically they
are 1024, 2048 or 4096 only.
mkmountpoint exemptpath
mkmountpoint and rmmountpoint are
specialized calls that can be used to create extra mountpoints
before mounting the first filesystem.
These calls are only necessary in some very limited circumstances, mainly the case where you want to mount a mix of unrelated and/or read-only filesystems together.
For example, live CDs often contain a "Russian doll" nest of filesystems, an ISO outer layer, with a squashfs image inside, with an ext2/3 image inside that. You can unpack this as follows in guestfish:
add-ro Fedora-11-i686-Live.iso run mkmountpoint /cd mkmountpoint /squash mkmountpoint /ext3 mount /dev/sda /cd mount-loop /cd/LiveOS/squashfs.img /squash mount-loop /squash/LiveOS/ext3fs.img /ext3
The inner filesystem is now unpacked under the /ext3 mountpoint.
mknod mode devmajor devminor path
This call creates block or character special devices, or named pipes (FIFOs).
The mode parameter should be the mode, using the standard
constants. devmajor and devminor are the
device major and minor numbers, only used when creating block
and character special devices.
mknod-b mode devmajor devminor path
This call creates a block device node called path with
mode mode and device major/minor devmajor and devminor.
It is just a convenient wrapper around mknod.
mknod-c mode devmajor devminor path
This call creates a char device node called path with
mode mode and device major/minor devmajor and devminor.
It is just a convenient wrapper around mknod.
mkswap device
Create a swap partition on device.
mkswap-L label device
Create a swap partition on device with label label.
Note that you cannot attach a swap label to a block device
(eg. /dev/sda), just to a partition. This appears to be
a limitation of the kernel or swap tools.
mkswap-U uuid device
Create a swap partition on device with UUID uuid.
mkswap-file path
Create a swap file.
This command just writes a swap file signature to an existing
file. To create the file itself, use something like fallocate.
modprobe modulename
This loads a kernel module in the appliance.
The kernel module must have been whitelisted when libguestfs
was built (see appliance/kmod.whitelist.in in the source).
mount device mountpoint
Mount a guest disk at a position in the filesystem. Block devices
are named /dev/sda, /dev/sdb and so on, as they were added to
the guest. If those block devices contain partitions, they will have
the usual names (eg. /dev/sda1). Also LVM /dev/VG/LV-style
names can be used.
The rules are the same as for mount(2): A filesystem must
first be mounted on / before others can be mounted. Other
filesystems can only be mounted on directories which already
exist.
The mounted filesystem is writable, if we have sufficient permissions on the underlying device.
The filesystem options sync and noatime are set with this
call, in order to improve reliability.
mount-loop file mountpoint
This command lets you mount file (a filesystem image
in a file) on a mount point. It is entirely equivalent to
the command mount -o loop file mountpoint.
mount-options options device mountpoint
This is the same as the mount command, but it
allows you to set the mount options as for the
mount(8) -o flag.
mount-ro device mountpoint
This is the same as the mount command, but it
mounts the filesystem with the read-only (-o ro) flag.
mount-vfs options vfstype device mountpoint
This is the same as the mount command, but it
allows you to set both the mount options and the vfstype
as for the mount(8) -o and -t flags.
mountpoints
This call is similar to mounts. That call returns
a list of devices. This one returns a hash table (map) of
device name to directory where the device is mounted.
mounts
This returns the list of currently mounted filesystems. It returns
the list of devices (eg. /dev/sda1, /dev/VG/LV).
Some internal mounts are not shown.
See also: mountpoints
mv src dest
This moves a file from src to dest where dest is
either a destination filename or destination directory.
ntfs-3g-probe true|false device
This command runs the ntfs-3g.probe(8) command which probes
an NTFS device for mountability. (Not all NTFS volumes can
be mounted read-write, and some cannot be mounted at all).
rw is a boolean flag. Set it to true if you want to test
if the volume can be mounted read-write. Set it to false if
you want to test if the volume can be mounted read-only.
The return value is an integer which 0 if the operation
would succeed, or some non-zero value documented in the
ntfs-3g.probe(8) manual page.
ping-daemon
This is a test probe into the guestfs daemon running inside the qemu subprocess. Calling this function checks that the daemon responds to the ping message, without affecting the daemon or attached block device(s) in any other way.
pvcreate device
This creates an LVM physical volume on the named device,
where device should usually be a partition name such
as /dev/sda1.
pvremove device
This wipes a physical volume device so that LVM will no longer
recognise it.
The implementation uses the pvremove command which refuses to
wipe physical volumes that contain any volume groups, so you have
to remove those first.
pvresize device
This resizes (expands or shrinks) an existing LVM physical volume to match the new size of the underlying device.
pvs
List all the physical volumes detected. This is the equivalent of the pvs(8) command.
This returns a list of just the device names that contain
PVs (eg. /dev/sda2).
See also pvs-full.
pvs-full
List all the physical volumes detected. This is the equivalent of the pvs(8) command. The "full" version includes all fields.
read-file path
This calls returns the contents of the file path as a
buffer.
Unlike cat, this function can correctly
handle files that contain embedded ASCII NUL characters.
However unlike download, this function is limited
in the total size of file that can be handled.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
read-lines path
Return the contents of the file named path.
The file contents are returned as a list of lines. Trailing
LF and CRLF character sequences are not returned.
Note that this function cannot correctly handle binary files
(specifically, files containing \0 character which is treated
as end of line). For those you need to use the read-file
function which has a more complex interface.
readdir dir
This returns the list of directory entries in directory dir.
All entries in the directory are returned, including . and
... The entries are not sorted, but returned in the same
order as the underlying filesystem.
Also this call returns basic file type information about each
file. The ftyp field will contain one of the following characters:
Block special
Char special
Directory
FIFO (named pipe)
Symbolic link
Regular file
Socket
Unknown file type
The readdir(3) returned a d_type field with an
unexpected value
This function is primarily intended for use by programs. To
get a simple list of names, use ls. To get a printable
directory for human consumption, use ll.
readlink path
This command reads the target of a symbolic link.
realpath path
Return the canonicalized absolute pathname of path. The
returned path has no ., .. or symbolic link path elements.
removexattr xattr path
This call removes the extended attribute named xattr
of the file path.
See also: lremovexattr, attr(5).
resize2fs device
This resizes an ext2 or ext3 filesystem to match the size of the underlying device.
Note: It is sometimes required that you run e2fsck-f
on the device before calling this command. For unknown reasons
resize2fs sometimes gives an error about this and sometimes not.
In any case, it is always safe to call e2fsck-f before
calling this function.
rm path
Remove the single file path.
rm-rf path
Remove the file or directory path, recursively removing the
contents if its a directory. This is like the rm -rf shell
command.
rmdir path
Remove the single directory path.
rmmountpoint exemptpath
This calls removes a mountpoint that was previously created
with mkmountpoint. See mkmountpoint
for full details.
scrub-device device
This command writes patterns over device to make data retrieval
more difficult.
It is an interface to the scrub(1) program. See that manual page for more details.
This command is dangerous. Without careful use you can easily destroy all your data.
scrub-file file
This command writes patterns over a file to make data retrieval more difficult.
The file is removed after scrubbing.
It is an interface to the scrub(1) program. See that manual page for more details.
scrub-freespace dir
This command creates the directory dir and then fills it
with files until the filesystem is full, and scrubs the files
as for scrub-file, and deletes them.
The intention is to scrub any free space on the partition
containing dir.
It is an interface to the scrub(1) program. See that manual page for more details.
set-append append
This function is used to add additional options to the guest kernel command line.
The default is NULL unless overridden by setting
LIBGUESTFS_APPEND environment variable.
Setting append to NULL means no additional options
are passed (libguestfs always adds a few of its own).
set-autosync true|false
If autosync is true, this enables autosync. Libguestfs will make a
best effort attempt to run umount-all followed by
sync when the handle is closed
(also if the program exits without closing handles).
This is disabled by default (except in guestfish where it is enabled by default).
set-direct true|false
If the direct appliance mode flag is enabled, then stdin and stdout are passed directly through to the appliance once it is launched.
One consequence of this is that log messages aren't caught
by the library and handled by set-log-message-callback,
but go straight to stdout.
You probably don't want to use this unless you know what you are doing.
The default is disabled.
set-e2label device label
This sets the ext2/3/4 filesystem label of the filesystem on
device to label. Filesystem labels are limited to
16 characters.
You can use either tune2fs-l or get-e2label
to return the existing label on a filesystem.
set-e2uuid device uuid
This sets the ext2/3/4 filesystem UUID of the filesystem on
device to uuid. The format of the UUID and alternatives
such as clear, random and time are described in the
tune2fs(8) manpage.
You can use either tune2fs-l or get-e2uuid
to return the existing UUID of a filesystem.
set-memsize memsize
This sets the memory size in megabytes allocated to the
qemu subprocess. This only has any effect if called before
launch.
You can also change this by setting the environment
variable LIBGUESTFS_MEMSIZE before the handle is
created.
For more information on the architecture of libguestfs, see guestfs(3).
set-path searchpath
Set the path that libguestfs searches for kernel and initrd.img.
The default is $libdir/guestfs unless overridden by setting
LIBGUESTFS_PATH environment variable.
Setting path to NULL restores the default path.
set-qemu qemu
Set the qemu binary that we will use.
The default is chosen when the library was compiled by the configure script.
You can also override this by setting the LIBGUESTFS_QEMU
environment variable.
Setting qemu to NULL restores the default qemu binary.
set-selinux true|false
This sets the selinux flag that is passed to the appliance
at boot time. The default is selinux=0 (disabled).
Note that if SELinux is enabled, it is always in
Permissive mode (enforcing=0).
For more information on the architecture of libguestfs, see guestfs(3).
set-trace true|false
If the command trace flag is set to 1, then commands are printed on stdout before they are executed in a format which is very similar to the one used by guestfish. In other words, you can run a program with this enabled, and you will get out a script which you can feed to guestfish to perform the same set of actions.
If you want to trace C API calls into libguestfs (and
other libraries) then possibly a better way is to use
the external ltrace(1) command.
Command traces are disabled unless the environment variable
LIBGUESTFS_TRACE is defined and set to 1.
set-verbose true|false
If verbose is true, this turns on verbose messages (to stderr).
Verbose messages are disabled unless the environment variable
LIBGUESTFS_DEBUG is defined and set to 1.
setcon context
This sets the SELinux security context of the daemon
to the string context.
See the documentation about SELINUX in guestfs(3).
setxattr xattr val vallen path
This call sets the extended attribute named xattr
of the file path to the value val (of length vallen).
The value is arbitrary 8 bit data.
See also: lsetxattr, attr(5).
sfdisk device cyls heads sectors 'lines ...'
This is a direct interface to the sfdisk(8) program for creating partitions on block devices.
device should be a block device, for example /dev/sda.
cyls, heads and sectors are the number of cylinders, heads
and sectors on the device, which are passed directly to sfdisk as
the -C, -H and -S parameters. If you pass 0 for any
of these, then the corresponding parameter is omitted. Usually for
'large' disks, you can just pass 0 for these, but for small
(floppy-sized) disks, sfdisk (or rather, the kernel) cannot work
out the right geometry and you will need to tell it.
lines is a list of lines that we feed to sfdisk. For more
information refer to the sfdisk(8) manpage.
To create a single partition occupying the whole disk, you would
pass lines as a single element list, when the single element being
the string , (comma).
See also: sfdisk-l, sfdisk-N
This command is dangerous. Without careful use you can easily destroy all your data.
sfdiskM device 'lines ...'
This is a simplified interface to the sfdisk
command, where partition sizes are specified in megabytes
only (rounded to the nearest cylinder) and you don't need
to specify the cyls, heads and sectors parameters which
were rarely if ever used anyway.
See also sfdisk and the sfdisk(8) manpage.
This command is dangerous. Without careful use you can easily destroy all your data.
sfdisk-N device partnum cyls heads sectors line
This runs sfdisk(8) option to modify just the single
partition n (note: n counts from 1).
For other parameters, see sfdisk. You should usually
pass 0 for the cyls/heads/sectors parameters.
This command is dangerous. Without careful use you can easily destroy all your data.
sfdisk-disk-geometry device
This displays the disk geometry of device read from the
partition table. Especially in the case where the underlying
block device has been resized, this can be different from the
kernel's idea of the geometry (see sfdisk-kernel-geometry).
The result is in human-readable format, and not designed to be parsed.
sfdisk-kernel-geometry device
This displays the kernel's idea of the geometry of device.
The result is in human-readable format, and not designed to be parsed.
sfdisk-l device
This displays the partition table on device, in the
human-readable output of the sfdisk(8) command. It is
not intended to be parsed.
sh command
This call runs a command from the guest filesystem via the
guest's /bin/sh.
This is like command, but passes the command to:
/bin/sh -c "command"
Depending on the guest's shell, this usually results in wildcards being expanded, shell expressions being interpolated and so on.
All the provisos about command apply to this call.
sh-lines command
This is the same as sh, but splits the result
into a list of lines.
See also: command-lines
sleep secs
Sleep for secs seconds.
stat path
Returns file information for the given path.
This is the same as the stat(2) system call.
statvfs path
Returns file system statistics for any mounted file system.
path should be a file or directory in the mounted file system
(typically it is the mount point itself, but it doesn't need to be).
This is the same as the statvfs(2) system call.
strings path
This runs the strings(1) command on a file and returns the list of printable strings found.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
strings-e encoding path
This is like the strings command, but allows you to
specify the encoding.
See the strings(1) manpage for the full list of encodings.
Commonly useful encodings are l (lower case L) which will
show strings inside Windows/x86 files.
The returned strings are transcoded to UTF-8.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
swapoff-device device
This command disables the libguestfs appliance swap
device or partition named device.
See swapon-device.
swapoff-file file
This command disables the libguestfs appliance swap on file.
swapoff-label label
This command disables the libguestfs appliance swap on labeled swap partition.
swapoff-uuid uuid
This command disables the libguestfs appliance swap partition with the given UUID.
swapon-device device
This command enables the libguestfs appliance to use the
swap device or partition named device. The increased
memory is made available for all commands, for example
those run using command or sh.
Note that you should not swap to existing guest swap partitions unless you know what you are doing. They may contain hibernation information, or other information that the guest doesn't want you to trash. You also risk leaking information about the host to the guest this way. Instead, attach a new host device to the guest and swap on that.
swapon-file file
This command enables swap to a file.
See swapon-device for other notes.
swapon-label label
This command enables swap to a labeled swap partition.
See swapon-device for other notes.
swapon-uuid uuid
This command enables swap to a swap partition with the given UUID.
See swapon-device for other notes.
sync
This syncs the disk, so that any writes are flushed through to the underlying disk image.
You should always call this if you have modified a disk image, before closing the handle.
tail path
This command returns up to the last 10 lines of a file as a list of strings.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
tail-n nrlines path
If the parameter nrlines is a positive number, this returns the last
nrlines lines of the file path.
If the parameter nrlines is a negative number, this returns lines
from the file path, starting with the -nrlinesth line.
If the parameter nrlines is zero, this returns an empty list.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
tar-in (tarfile|-) directory
This command uploads and unpacks local file tarfile (an
uncompressed tar file) into directory.
To upload a compressed tarball, use tgz-in.
Use - instead of a filename to read/write from stdin/stdout.
tar-out directory (tarfile|-)
This command packs the contents of directory and downloads
it to local file tarfile.
To download a compressed tarball, use tgz-out.
Use - instead of a filename to read/write from stdin/stdout.
tgz-in (tarball|-) directory
This command uploads and unpacks local file tarball (a
gzip compressed tar file) into directory.
To upload an uncompressed tarball, use tar-in.
Use - instead of a filename to read/write from stdin/stdout.
tgz-out directory (tarball|-)
This command packs the contents of directory and downloads
it to local file tarball.
To download an uncompressed tarball, use tar-out.
Use - instead of a filename to read/write from stdin/stdout.
touch path
Touch acts like the touch(1) command. It can be used to update the timestamps on a file, or, if the file does not exist, to create a new zero-length file.
tune2fs-l device
This returns the contents of the ext2, ext3 or ext4 filesystem
superblock on device.
It is the same as running tune2fs -l device. See tune2fs(8)
manpage for more details. The list of fields returned isn't
clearly defined, and depends on both the version of tune2fs
that libguestfs was built against, and the filesystem itself.
umask mask
This function sets the mask used for creating new files and
device nodes to mask & 0777.
Typical umask values would be 022 which creates new files
with permissions like "-rw-r--r--" or "-rwxr-xr-x", and
002 which creates new files with permissions like
"-rw-rw-r--" or "-rwxrwxr-x".
The default umask is 022. This is important because it
means that directories and device nodes will be created with
0644 or 0755 mode even if you specify 0777.
See also umask(2), mknod, mkdir.
This call returns the previous umask.
umount pathordevice
This unmounts the given filesystem. The filesystem may be specified either by its mountpoint (path) or the device which contains the filesystem.
umount-all
This unmounts all mounted filesystems.
Some internal mounts are not unmounted by this call.
upload (filename|-) remotefilename
Upload local file filename to remotefilename on the
filesystem.
filename can also be a named pipe.
See also download.
Use - instead of a filename to read/write from stdin/stdout.
version
Return the libguestfs version number that the program is linked against.
Note that because of dynamic linking this is not necessarily
the version of libguestfs that you compiled against. You can
compile the program, and then at runtime dynamically link
against a completely different libguestfs.so library.
This call was added in version 1.0.58. In previous
versions of libguestfs there was no way to get the version
number. From C code you can use ELF weak linking tricks to find out if
this symbol exists (if it doesn't, then it's an earlier version).
The call returns a structure with four elements. The first
three (major, minor and release) are numbers and
correspond to the usual version triplet. The fourth element
(extra) is a string and is normally empty, but may be
used for distro-specific information.
To construct the original version string:
$major.$minor.$release$extra
Note: Don't use this call to test for availability of features. Distro backports makes this unreliable.
vfs-type device
This command gets the block device type corresponding to
a mounted device called device.
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 mount call).
vg-activate true|false 'volgroups ...'
This command activates or (if activate is false) deactivates
all logical volumes in the listed volume groups volgroups.
If activated, then they are made known to the
kernel, ie. they appear as /dev/mapper devices. If deactivated,
then those devices disappear.
This command is the same as running vgchange -a y|n volgroups...
Note that if volgroups is an empty list then all volume groups
are activated or deactivated.
vg-activate-all true|false
This command activates or (if activate is false) deactivates
all logical volumes in all volume groups.
If activated, then they are made known to the
kernel, ie. they appear as /dev/mapper devices. If deactivated,
then those devices disappear.
This command is the same as running vgchange -a y|n
vgcreate volgroup 'physvols ...'
This creates an LVM volume group called volgroup
from the non-empty list of physical volumes physvols.
vgremove vgname
Remove an LVM volume group vgname, (for example VG).
This also forcibly removes all logical volumes in the volume group (if any).
vgs
List all the volumes groups detected. This is the equivalent of the vgs(8) command.
This returns a list of just the volume group names that were
detected (eg. VolGroup00).
See also vgs-full.
vgs-full
List all the volumes groups detected. This is the equivalent of the vgs(8) command. The "full" version includes all fields.
wc-c path
This command counts the characters in a file, using the
wc -c external command.
wc-l path
This command counts the lines in a file, using the
wc -l external command.
wc-w path
This command counts the words in a file, using the
wc -w external command.
write-file path content size
This call creates a file called path. The contents of the
file is the string content (which can contain any 8 bit data),
with length size.
As a special case, if size is 0
then the length is calculated using strlen (so in this case
the content cannot contain embedded ASCII NULs).
NB. Owing to a bug, writing content containing ASCII NUL
characters does not work, even if the length is specified.
We hope to resolve this bug in a future version. In the meantime
use upload.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
zegrep regex path
This calls the external zegrep program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
zegrepi regex path
This calls the external zegrep -i program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
zero device
This command writes zeroes over the first few blocks of device.
How many blocks are zeroed isn't specified (but it's not enough to securely wipe the device). It should be sufficient to remove any partition tables, filesystem superblocks and so on.
See also: scrub-device.
zerofree device
This runs the zerofree program on device. This program
claims to zero unused inodes and disk blocks on an ext2/3
filesystem, thus making it possible to compress the filesystem
more effectively.
You should not run this program if the filesystem is mounted.
It is possible that using this program can damage the filesystem or data on the filesystem.
zfgrep pattern path
This calls the external zfgrep program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
zfgrepi pattern path
This calls the external zfgrep -i program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
zfile meth path
This command runs file after first decompressing path
using method.
method must be one of gzip, compress or bzip2.
Since 1.0.63, use file instead which can now
process compressed files.
This function is deprecated.
In new code, use the file call instead.
Deprecated functions will not be removed from the API, but the fact that they are deprecated indicates that there are problems with correct use of these functions.
zgrep regex path
This calls the external zgrep program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
zgrepi regex path
This calls the external zgrep -i program and returns the
matching lines.
Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP.
The edit command uses $EDITOR as the editor. If not
set, it uses vi.
Used with the --remote option to specify the remote guestfish process to control. See section REMOTE CONTROL GUESTFISH OVER A SOCKET.
If compiled with GNU readline support, then the command history
is saved in $HOME/.guestfish
Pass additional options to the guest kernel.
Set LIBGUESTFS_DEBUG=1 to enable verbose messages. This has the
same effect as using the -v option.
Set the memory allocated to the qemu process, in megabytes. For example:
LIBGUESTFS_MEMSIZE=700
Set the path that guestfish uses to search for kernel and initrd.img. See the discussion of paths in guestfs(3).
Set the default qemu binary that libguestfs uses. If not set, then the qemu which was found at compile time by the configure script is used.
Set LIBGUESTFS_TRACE=1 to enable command traces.
The more command uses $PAGER as the pager. If not
set, it uses more.
Location of temporary directory, defaults to /tmp.
If libguestfs was compiled to use the supermin appliance then each
handle will require rather a large amount of space in this directory
for short periods of time (~ 80 MB). You can use $TMPDIR to
configure another directory to use in case /tmp is not large
enough.
guestfish returns 0 if the commands completed without error, or 1 if there was an error.
guestfs(3), http://libguestfs.org/, virt-cat(1), virt-edit(1), virt-ls(1), virt-rescue(1), virt-tar(1).
Richard W.M. Jones (rjones at redhat dot com)
Copyright (C) 2009 Red Hat Inc. 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.