X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=java%2Fcom%2Fredhat%2Fet%2Flibguestfs%2FGuestFS.java;h=26f1aaa69b05c3d4b9d9c0c065a8d0b7e210de8e;hb=15e0fd573a87488c66cb3a6f0da01f3ab5f2f6ed;hp=515fc77b57d907b9cfb93fda4011aed156f70d19;hpb=ac286b26df1aabceca26dac66c325a3676ace4cc;p=libguestfs.git diff --git a/java/com/redhat/et/libguestfs/GuestFS.java b/java/com/redhat/et/libguestfs/GuestFS.java index 515fc77..26f1aaa 100644 --- a/java/com/redhat/et/libguestfs/GuestFS.java +++ b/java/com/redhat/et/libguestfs/GuestFS.java @@ -535,6 +535,27 @@ public class GuestFS { 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. @@ -1420,7 +1441,7 @@ public class GuestFS { * 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 @@ -1487,6 +1508,11 @@ public class GuestFS { * 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. @@ -2487,4 +2513,169 @@ public class GuestFS { 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 + * + * 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; + }