throws LibGuestFSException;
/**
+ * add options to kernel command line
+ *
+ * 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.
+ *
+ * The string "append" is stashed in the libguestfs handle,
+ * so the caller must make sure it remains valid for the
+ * lifetime of the handle.
+ *
+ * Setting "append" to "NULL" means *no* additional options
+ * are passed (libguestfs always adds a few of its own).
+ *
+ * @throws LibGuestFSException
+ */
+ public void set_append (String append)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("set_append: handle is closed");
+ _set_append (g, append);
+ }
+ private native void _set_append (long g, String append)
+ throws LibGuestFSException;
+
+ /**
+ * get the additional kernel options
+ *
+ * Return the additional kernel options which are added to
+ * the guest kernel command line.
+ *
+ * If "NULL" then no options are added.
+ *
+ * @throws LibGuestFSException
+ */
+ public String get_append ()
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("get_append: handle is closed");
+ return _get_append (g);
+ }
+ private native String _get_append (long g)
+ throws LibGuestFSException;
+
+ /**
* set autosync mode
*
* If "autosync" is true, this enables autosync. Libguestfs
- * will make a best effort attempt to run "g.sync" when the
- * handle is closed (also if the program exits without
- * closing handles).
+ * will make a best effort attempt to run "g.umount_all"
+ * followed by "g.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).
*
* @throws LibGuestFSException
*/
throws LibGuestFSException;
/**
+ * leave the busy state
+ *
+ * This sets the state to "READY", or if in "CONFIG" then
+ * it leaves the state as is. This is only used when
+ * implementing actions using the low-level API.
+ *
+ * For more information on states, see guestfs(3).
+ *
+ * @throws LibGuestFSException
+ */
+ public void end_busy ()
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("end_busy: handle is closed");
+ _end_busy (g);
+ }
+ private native void _end_busy (long g)
+ throws LibGuestFSException;
+
+ /**
* mount a guest disk at a position in the filesystem
*
* Mount a guest disk at a position in the filesystem.
* make a filesystem
*
* This creates a filesystem on "device" (usually a
- * partition of LVM logical volume). The filesystem type is
+ * partition or LVM logical volume). The filesystem type is
* "fstype", for example "ext3".
*
* @throws LibGuestFSException
* 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 "g.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.
* Subsequent elements are parameters. The list must be
* non-empty (ie. must contain a program name).
*
+ * 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
* 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.
+ *
* @throws LibGuestFSException
*/
public String command (String[] arguments)
* This is the same as "g.command", but splits the result
* into a list of 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.
+ *
* @throws LibGuestFSException
*/
public String[] command_lines (String[] arguments)
throws LibGuestFSException;
/**
- * get ext2/ext3 superblock details
+ * get ext2/ext3/ext4 superblock details
*
- * This returns the contents of the ext2 or ext3 filesystem
- * superblock on "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
private native void _mount_vfs (long g, String options, String vfstype, String device, String mountpoint)
throws LibGuestFSException;
+ /**
+ * debugging and internals
+ *
+ * The "g.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.
+ *
+ * @throws LibGuestFSException
+ */
+ public String debug (String subcmd, String[] extraargs)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("debug: handle is closed");
+ return _debug (g, subcmd, extraargs);
+ }
+ private native String _debug (long g, String subcmd, String[] extraargs)
+ throws LibGuestFSException;
+
+ /**
+ * remove an LVM logical volume
+ *
+ * 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".
+ *
+ * @throws LibGuestFSException
+ */
+ public void lvremove (String device)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("lvremove: handle is closed");
+ _lvremove (g, device);
+ }
+ private native void _lvremove (long g, String device)
+ throws LibGuestFSException;
+
+ /**
+ * remove an LVM volume group
+ *
+ * Remove an LVM volume group "vgname", (for example "VG").
+ *
+ * This also forcibly removes all logical volumes in the
+ * volume group (if any).
+ *
+ * @throws LibGuestFSException
+ */
+ public void vgremove (String vgname)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("vgremove: handle is closed");
+ _vgremove (g, vgname);
+ }
+ private native void _vgremove (long g, String vgname)
+ throws LibGuestFSException;
+
+ /**
+ * remove an LVM physical volume
+ *
+ * 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.
+ *
+ * @throws LibGuestFSException
+ */
+ public void pvremove (String device)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("pvremove: handle is closed");
+ _pvremove (g, device);
+ }
+ private native void _pvremove (long g, String device)
+ throws LibGuestFSException;
+
+ /**
+ * set the ext2/3/4 filesystem 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 "g.tune2fs_l" or "g.get_e2label" to
+ * return the existing label on a filesystem.
+ *
+ * @throws LibGuestFSException
+ */
+ public void set_e2label (String device, String label)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("set_e2label: handle is closed");
+ _set_e2label (g, device, label);
+ }
+ private native void _set_e2label (long g, String device, String label)
+ throws LibGuestFSException;
+
+ /**
+ * get the ext2/3/4 filesystem label
+ *
+ * This returns the ext2/3/4 filesystem label of the
+ * filesystem on "device".
+ *
+ * @throws LibGuestFSException
+ */
+ public String get_e2label (String device)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("get_e2label: handle is closed");
+ return _get_e2label (g, device);
+ }
+ private native String _get_e2label (long g, String device)
+ throws LibGuestFSException;
+
+ /**
+ * set the ext2/3/4 filesystem 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 "g.tune2fs_l" or "g.get_e2uuid" to
+ * return the existing UUID of a filesystem.
+ *
+ * @throws LibGuestFSException
+ */
+ public void set_e2uuid (String device, String uuid)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("set_e2uuid: handle is closed");
+ _set_e2uuid (g, device, uuid);
+ }
+ private native void _set_e2uuid (long g, String device, String uuid)
+ throws LibGuestFSException;
+
+ /**
+ * get the ext2/3/4 filesystem UUID
+ *
+ * This returns the ext2/3/4 filesystem UUID of the
+ * filesystem on "device".
+ *
+ * @throws LibGuestFSException
+ */
+ public String get_e2uuid (String device)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("get_e2uuid: handle is closed");
+ return _get_e2uuid (g, device);
+ }
+ private native String _get_e2uuid (long g, String device)
+ throws LibGuestFSException;
+
+ /**
+ * run the filesystem checker
+ *
+ * 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".
+ *
+ * @throws LibGuestFSException
+ */
+ public int fsck (String fstype, String device)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("fsck: handle is closed");
+ return _fsck (g, fstype, device);
+ }
+ private native int _fsck (long g, String fstype, String device)
+ throws LibGuestFSException;
+
+ /**
+ * write zeroes to the 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.
+ *
+ * @throws LibGuestFSException
+ */
+ public void zero (String device)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("zero: handle is closed");
+ _zero (g, device);
+ }
+ private native void _zero (long g, String device)
+ throws LibGuestFSException;
+
+ /**
+ * install GRUB
+ *
+ * This command installs GRUB (the Grand Unified
+ * Bootloader) on "device", with the root directory being
+ * "root".
+ *
+ * @throws LibGuestFSException
+ */
+ public void grub_install (String root, String device)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("grub_install: handle is closed");
+ _grub_install (g, root, device);
+ }
+ private native void _grub_install (long g, String root, String device)
+ throws LibGuestFSException;
+
+ /**
+ * copy a file
+ *
+ * This copies a file from "src" to "dest" where "dest" is
+ * either a destination filename or destination directory.
+ *
+ * @throws LibGuestFSException
+ */
+ public void cp (String src, String dest)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("cp: handle is closed");
+ _cp (g, src, dest);
+ }
+ private native void _cp (long g, String src, String dest)
+ throws LibGuestFSException;
+
+ /**
+ * copy a file or directory recursively
+ *
+ * This copies a file or directory from "src" to "dest"
+ * recursively using the "cp -a" command.
+ *
+ * @throws LibGuestFSException
+ */
+ public void cp_a (String src, String dest)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("cp_a: handle is closed");
+ _cp_a (g, src, dest);
+ }
+ private native void _cp_a (long g, String src, String dest)
+ throws LibGuestFSException;
+
+ /**
+ * move a file
+ *
+ * This moves a file from "src" to "dest" where "dest" is
+ * either a destination filename or destination directory.
+ *
+ * @throws LibGuestFSException
+ */
+ public void mv (String src, String dest)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("mv: handle is closed");
+ _mv (g, src, dest);
+ }
+ private native void _mv (long g, String src, String dest)
+ throws LibGuestFSException;
+
+ /**
+ * drop kernel page cache, dentries and inodes
+ *
+ * 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.
+ *
+ * @throws LibGuestFSException
+ */
+ public void drop_caches (int whattodrop)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("drop_caches: handle is closed");
+ _drop_caches (g, whattodrop);
+ }
+ private native void _drop_caches (long g, int whattodrop)
+ throws LibGuestFSException;
+
+ /**
+ * return kernel messages
+ *
+ * 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 "g.set_verbose" or by setting the
+ * environment variable "LIBGUESTFS_DEBUG=1" before running
+ * the program.
+ *
+ * @throws LibGuestFSException
+ */
+ public String dmesg ()
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("dmesg: handle is closed");
+ return _dmesg (g);
+ }
+ private native String _dmesg (long g)
+ throws LibGuestFSException;
+
+ /**
+ * ping the guest 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.
+ *
+ * @throws LibGuestFSException
+ */
+ public void ping_daemon ()
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("ping_daemon: handle is closed");
+ _ping_daemon (g);
+ }
+ private native void _ping_daemon (long g)
+ throws LibGuestFSException;
+
+ /**
+ * test if two files have equal contents
+ *
+ * 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.
+ *
+ * @throws LibGuestFSException
+ */
+ public boolean equal (String file1, String file2)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("equal: handle is closed");
+ return _equal (g, file1, file2);
+ }
+ private native boolean _equal (long g, String file1, String file2)
+ throws LibGuestFSException;
+
+ /**
+ * print the printable strings in a file
+ *
+ * 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.
+ *
+ * @throws LibGuestFSException
+ */
+ public String[] strings (String path)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("strings: handle is closed");
+ return _strings (g, path);
+ }
+ private native String[] _strings (long g, String path)
+ throws LibGuestFSException;
+
+ /**
+ * print the printable strings in a file
+ *
+ * This is like the "g.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.
+ *
+ * @throws LibGuestFSException
+ */
+ public String[] strings_e (String encoding, String path)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("strings_e: handle is closed");
+ return _strings_e (g, encoding, path);
+ }
+ private native String[] _strings_e (long g, String encoding, String path)
+ throws LibGuestFSException;
+
+ /**
+ * dump a file in hexadecimal
+ *
+ * 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.
+ *
+ * @throws LibGuestFSException
+ */
+ public String hexdump (String path)
+ throws LibGuestFSException
+ {
+ if (g == 0)
+ throw new LibGuestFSException ("hexdump: handle is closed");
+ return _hexdump (g, path);
+ }
+ private native String _hexdump (long g, String path)
+ throws LibGuestFSException;
+
}
git.annexia.org / libguestfs.git / blobdiff