java/com/redhat/et/libguestfs/GuestFS.java

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 package com.redhat.et.libguestfs;
  23
  24 import java.util.HashMap;
  25 import com.redhat.et.libguestfs.LibGuestFSException;
  26 import com.redhat.et.libguestfs.PV;
  27 import com.redhat.et.libguestfs.VG;
  28 import com.redhat.et.libguestfs.LV;
  29 import com.redhat.et.libguestfs.Stat;
  30 import com.redhat.et.libguestfs.StatVFS;
  31 import com.redhat.et.libguestfs.IntBool;
  32
  33 /**
  34  * The GuestFS object is a libguestfs handle.
  35  *
  36  * @author rjones
  37  */
  38 public class GuestFS {
  39   // Load the native code.
  40   static {
  41     System.loadLibrary ("guestfs_jni");
  42   }
  43
  44   /**
  45    * The native guestfs_h pointer.
  46    */
  47   long g;
  48
  49   /**
  50    * Create a libguestfs handle.
  51    *
  52    * @throws LibGuestFSException
  53    */
  54   public GuestFS () throws LibGuestFSException
  55   {
  56     g = _create ();
  57   }
  58   private native long _create () throws LibGuestFSException;
  59
  60   /**
  61    * Close a libguestfs handle.
  62    *
  63    * You can also leave handles to be collected by the garbage
  64    * collector, but this method ensures that the resources used
  65    * by the handle are freed up immediately.  If you call any
  66    * other methods after closing the handle, you will get an
  67    * exception.
  68    *
  69    * @throws LibGuestFSException
  70    */
  71   public void close () throws LibGuestFSException
  72   {
  73     if (g != 0)
  74       _close (g);
  75     g = 0;
  76   }
  77   private native void _close (long g) throws LibGuestFSException;
  78
  79   public void finalize () throws LibGuestFSException
  80   {
  81     close ();
  82   }
  83
  84   /**
  85    * launch the qemu subprocess
  86    *
  87    * Internally libguestfs is implemented by running a
  88    * virtual machine using qemu(1).
  89    *
  90    * You should call this after configuring the handle (eg.
  91    * adding drives) but before performing any actions.
  92    *
  93    * @throws LibGuestFSException
  94    */
  95   public void launch ()
  96     throws LibGuestFSException
  97   {
  98     if (g == 0)
  99       throw new LibGuestFSException ("launch: handle is closed");
 100     _launch (g);
 101   }
 102   private native void _launch (long g)
 103     throws LibGuestFSException;
 104
 105   /**
 106    * wait until the qemu subprocess launches
 107    *
 108    * Internally libguestfs is implemented by running a
 109    * virtual machine using qemu(1).
 110    *
 111    * You should call this after "g.launch" to wait for the
 112    * launch to complete.
 113    *
 114    * @throws LibGuestFSException
 115    */
 116   public void wait_ready ()
 117     throws LibGuestFSException
 118   {
 119     if (g == 0)
 120       throw new LibGuestFSException ("wait_ready: handle is closed");
 121     _wait_ready (g);
 122   }
 123   private native void _wait_ready (long g)
 124     throws LibGuestFSException;
 125
 126   /**
 127    * kill the qemu subprocess
 128    *
 129    * This kills the qemu subprocess. You should never need to
 130    * call this.
 131    *
 132    * @throws LibGuestFSException
 133    */
 134   public void kill_subprocess ()
 135     throws LibGuestFSException
 136   {
 137     if (g == 0)
 138       throw new LibGuestFSException ("kill_subprocess: handle is closed");
 139     _kill_subprocess (g);
 140   }
 141   private native void _kill_subprocess (long g)
 142     throws LibGuestFSException;
 143
 144   /**
 145    * add an image to examine or modify
 146    *
 147    * This function adds a virtual machine disk image
 148    * "filename" to the guest. The first time you call this
 149    * function, the disk appears as IDE disk 0 ("/dev/sda") in
 150    * the guest, the second time as "/dev/sdb", and so on.
 151    *
 152    * You don't necessarily need to be root when using
 153    * libguestfs. However you obviously do need sufficient
 154    * permissions to access the filename for whatever
 155    * operations you want to perform (ie. read access if you
 156    * just want to read the image or write access if you want
 157    * to modify the image).
 158    *
 159    * This is equivalent to the qemu parameter "-drive
 160    * file=filename".
 161    *
 162    * @throws LibGuestFSException
 163    */
 164   public void add_drive (String filename)
 165     throws LibGuestFSException
 166   {
 167     if (g == 0)
 168       throw new LibGuestFSException ("add_drive: handle is closed");
 169     _add_drive (g, filename);
 170   }
 171   private native void _add_drive (long g, String filename)
 172     throws LibGuestFSException;
 173
 174   /**
 175    * add a CD-ROM disk image to examine
 176    *
 177    * This function adds a virtual CD-ROM disk image to the
 178    * guest.
 179    *
 180    * This is equivalent to the qemu parameter "-cdrom
 181    * filename".
 182    *
 183    * @throws LibGuestFSException
 184    */
 185   public void add_cdrom (String filename)
 186     throws LibGuestFSException
 187   {
 188     if (g == 0)
 189       throw new LibGuestFSException ("add_cdrom: handle is closed");
 190     _add_cdrom (g, filename);
 191   }
 192   private native void _add_cdrom (long g, String filename)
 193     throws LibGuestFSException;
 194
 195   /**
 196    * add qemu parameters
 197    *
 198    * This can be used to add arbitrary qemu command line
 199    * parameters of the form "-param value". Actually it's not
 200    * quite arbitrary - we prevent you from setting some
 201    * parameters which would interfere with parameters that we
 202    * use.
 203    *
 204    * The first character of "param" string must be a "-"
 205    * (dash).
 206    *
 207    * "value" can be NULL.
 208    *
 209    * @throws LibGuestFSException
 210    */
 211   public void config (String qemuparam, String qemuvalue)
 212     throws LibGuestFSException
 213   {
 214     if (g == 0)
 215       throw new LibGuestFSException ("config: handle is closed");
 216     _config (g, qemuparam, qemuvalue);
 217   }
 218   private native void _config (long g, String qemuparam, String qemuvalue)
 219     throws LibGuestFSException;
 220
 221   /**
 222    * set the qemu binary
 223    *
 224    * Set the qemu binary that we will use.
 225    *
 226    * The default is chosen when the library was compiled by
 227    * the configure script.
 228    *
 229    * You can also override this by setting the
 230    * "LIBGUESTFS_QEMU" environment variable.
 231    *
 232    * The string "qemu" is stashed in the libguestfs handle,
 233    * so the caller must make sure it remains valid for the
 234    * lifetime of the handle.
 235    *
 236    * Setting "qemu" to "NULL" restores the default qemu
 237    * binary.
 238    *
 239    * @throws LibGuestFSException
 240    */
 241   public void set_qemu (String qemu)
 242     throws LibGuestFSException
 243   {
 244     if (g == 0)
 245       throw new LibGuestFSException ("set_qemu: handle is closed");
 246     _set_qemu (g, qemu);
 247   }
 248   private native void _set_qemu (long g, String qemu)
 249     throws LibGuestFSException;
 250
 251   /**
 252    * get the qemu binary
 253    *
 254    * Return the current qemu binary.
 255    *
 256    * This is always non-NULL. If it wasn't set already, then
 257    * this will return the default qemu binary name.
 258    *
 259    * @throws LibGuestFSException
 260    */
 261   public String get_qemu ()
 262     throws LibGuestFSException
 263   {
 264     if (g == 0)
 265       throw new LibGuestFSException ("get_qemu: handle is closed");
 266     return _get_qemu (g);
 267   }
 268   private native String _get_qemu (long g)
 269     throws LibGuestFSException;
 270
 271   /**
 272    * set the search path
 273    *
 274    * Set the path that libguestfs searches for kernel and
 275    * initrd.img.
 276    *
 277    * The default is "$libdir/guestfs" unless overridden by
 278    * setting "LIBGUESTFS_PATH" environment variable.
 279    *
 280    * The string "path" is stashed in the libguestfs handle,
 281    * so the caller must make sure it remains valid for the
 282    * lifetime of the handle.
 283    *
 284    * Setting "path" to "NULL" restores the default path.
 285    *
 286    * @throws LibGuestFSException
 287    */
 288   public void set_path (String path)
 289     throws LibGuestFSException
 290   {
 291     if (g == 0)
 292       throw new LibGuestFSException ("set_path: handle is closed");
 293     _set_path (g, path);
 294   }
 295   private native void _set_path (long g, String path)
 296     throws LibGuestFSException;
 297
 298   /**
 299    * get the search path
 300    *
 301    * Return the current search path.
 302    *
 303    * This is always non-NULL. If it wasn't set already, then
 304    * this will return the default path.
 305    *
 306    * @throws LibGuestFSException
 307    */
 308   public String get_path ()
 309     throws LibGuestFSException
 310   {
 311     if (g == 0)
 312       throw new LibGuestFSException ("get_path: handle is closed");
 313     return _get_path (g);
 314   }
 315   private native String _get_path (long g)
 316     throws LibGuestFSException;
 317
 318   /**
 319    * set autosync mode
 320    *
 321    * If "autosync" is true, this enables autosync. Libguestfs
 322    * will make a best effort attempt to run "g.umount_all"
 323    * followed by "g.sync" when the handle is closed (also if
 324    * the program exits without closing handles).
 325    *
 326    * This is disabled by default (except in guestfish where
 327    * it is enabled by default).
 328    *
 329    * @throws LibGuestFSException
 330    */
 331   public void set_autosync (boolean autosync)
 332     throws LibGuestFSException
 333   {
 334     if (g == 0)
 335       throw new LibGuestFSException ("set_autosync: handle is closed");
 336     _set_autosync (g, autosync);
 337   }
 338   private native void _set_autosync (long g, boolean autosync)
 339     throws LibGuestFSException;
 340
 341   /**
 342    * get autosync mode
 343    *
 344    * Get the autosync flag.
 345    *
 346    * @throws LibGuestFSException
 347    */
 348   public boolean get_autosync ()
 349     throws LibGuestFSException
 350   {
 351     if (g == 0)
 352       throw new LibGuestFSException ("get_autosync: handle is closed");
 353     return _get_autosync (g);
 354   }
 355   private native boolean _get_autosync (long g)
 356     throws LibGuestFSException;
 357
 358   /**
 359    * set verbose mode
 360    *
 361    * If "verbose" is true, this turns on verbose messages (to
 362    * "stderr").
 363    *
 364    * Verbose messages are disabled unless the environment
 365    * variable "LIBGUESTFS_DEBUG" is defined and set to 1.
 366    *
 367    * @throws LibGuestFSException
 368    */
 369   public void set_verbose (boolean verbose)
 370     throws LibGuestFSException
 371   {
 372     if (g == 0)
 373       throw new LibGuestFSException ("set_verbose: handle is closed");
 374     _set_verbose (g, verbose);
 375   }
 376   private native void _set_verbose (long g, boolean verbose)
 377     throws LibGuestFSException;
 378
 379   /**
 380    * get verbose mode
 381    *
 382    * This returns the verbose messages flag.
 383    *
 384    * @throws LibGuestFSException
 385    */
 386   public boolean get_verbose ()
 387     throws LibGuestFSException
 388   {
 389     if (g == 0)
 390       throw new LibGuestFSException ("get_verbose: handle is closed");
 391     return _get_verbose (g);
 392   }
 393   private native boolean _get_verbose (long g)
 394     throws LibGuestFSException;
 395
 396   /**
 397    * is ready to accept commands
 398    *
 399    * This returns true iff this handle is ready to accept
 400    * commands (in the "READY" state).
 401    *
 402    * For more information on states, see guestfs(3).
 403    *
 404    * @throws LibGuestFSException
 405    */
 406   public boolean is_ready ()
 407     throws LibGuestFSException
 408   {
 409     if (g == 0)
 410       throw new LibGuestFSException ("is_ready: handle is closed");
 411     return _is_ready (g);
 412   }
 413   private native boolean _is_ready (long g)
 414     throws LibGuestFSException;
 415
 416   /**
 417    * is in configuration state
 418    *
 419    * This returns true iff this handle is being configured
 420    * (in the "CONFIG" state).
 421    *
 422    * For more information on states, see guestfs(3).
 423    *
 424    * @throws LibGuestFSException
 425    */
 426   public boolean is_config ()
 427     throws LibGuestFSException
 428   {
 429     if (g == 0)
 430       throw new LibGuestFSException ("is_config: handle is closed");
 431     return _is_config (g);
 432   }
 433   private native boolean _is_config (long g)
 434     throws LibGuestFSException;
 435
 436   /**
 437    * is launching subprocess
 438    *
 439    * This returns true iff this handle is launching the
 440    * subprocess (in the "LAUNCHING" state).
 441    *
 442    * For more information on states, see guestfs(3).
 443    *
 444    * @throws LibGuestFSException
 445    */
 446   public boolean is_launching ()
 447     throws LibGuestFSException
 448   {
 449     if (g == 0)
 450       throw new LibGuestFSException ("is_launching: handle is closed");
 451     return _is_launching (g);
 452   }
 453   private native boolean _is_launching (long g)
 454     throws LibGuestFSException;
 455
 456   /**
 457    * is busy processing a command
 458    *
 459    * This returns true iff this handle is busy processing a
 460    * command (in the "BUSY" state).
 461    *
 462    * For more information on states, see guestfs(3).
 463    *
 464    * @throws LibGuestFSException
 465    */
 466   public boolean is_busy ()
 467     throws LibGuestFSException
 468   {
 469     if (g == 0)
 470       throw new LibGuestFSException ("is_busy: handle is closed");
 471     return _is_busy (g);
 472   }
 473   private native boolean _is_busy (long g)
 474     throws LibGuestFSException;
 475
 476   /**
 477    * get the current state
 478    *
 479    * This returns the current state as an opaque integer.
 480    * This is only useful for printing debug and internal
 481    * error messages.
 482    *
 483    * For more information on states, see guestfs(3).
 484    *
 485    * @throws LibGuestFSException
 486    */
 487   public int get_state ()
 488     throws LibGuestFSException
 489   {
 490     if (g == 0)
 491       throw new LibGuestFSException ("get_state: handle is closed");
 492     return _get_state (g);
 493   }
 494   private native int _get_state (long g)
 495     throws LibGuestFSException;
 496
 497   /**
 498    * set state to busy
 499    *
 500    * This sets the state to "BUSY". This is only used when
 501    * implementing actions using the low-level API.
 502    *
 503    * For more information on states, see guestfs(3).
 504    *
 505    * @throws LibGuestFSException
 506    */
 507   public void set_busy ()
 508     throws LibGuestFSException
 509   {
 510     if (g == 0)
 511       throw new LibGuestFSException ("set_busy: handle is closed");
 512     _set_busy (g);
 513   }
 514   private native void _set_busy (long g)
 515     throws LibGuestFSException;
 516
 517   /**
 518    * set state to ready
 519    *
 520    * This sets the state to "READY". This is only used when
 521    * implementing actions using the low-level API.
 522    *
 523    * For more information on states, see guestfs(3).
 524    *
 525    * @throws LibGuestFSException
 526    */
 527   public void set_ready ()
 528     throws LibGuestFSException
 529   {
 530     if (g == 0)
 531       throw new LibGuestFSException ("set_ready: handle is closed");
 532     _set_ready (g);
 533   }
 534   private native void _set_ready (long g)
 535     throws LibGuestFSException;
 536
 537   /**
 538    * mount a guest disk at a position in the filesystem
 539    *
 540    * Mount a guest disk at a position in the filesystem.
 541    * Block devices are named "/dev/sda", "/dev/sdb" and so
 542    * on, as they were added to the guest. If those block
 543    * devices contain partitions, they will have the usual
 544    * names (eg. "/dev/sda1"). Also LVM "/dev/VG/LV"-style
 545    * names can be used.
 546    *
 547    * The rules are the same as for mount(2): A filesystem
 548    * must first be mounted on "/" before others can be
 549    * mounted. Other filesystems can only be mounted on
 550    * directories which already exist.
 551    *
 552    * The mounted filesystem is writable, if we have
 553    * sufficient permissions on the underlying device.
 554    *
 555    * The filesystem options "sync" and "noatime" are set with
 556    * this call, in order to improve reliability.
 557    *
 558    * @throws LibGuestFSException
 559    */
 560   public void mount (String device, String mountpoint)
 561     throws LibGuestFSException
 562   {
 563     if (g == 0)
 564       throw new LibGuestFSException ("mount: handle is closed");
 565     _mount (g, device, mountpoint);
 566   }
 567   private native void _mount (long g, String device, String mountpoint)
 568     throws LibGuestFSException;
 569
 570   /**
 571    * sync disks, writes are flushed through to the disk image
 572    *
 573    * This syncs the disk, so that any writes are flushed
 574    * through to the underlying disk image.
 575    *
 576    * You should always call this if you have modified a disk
 577    * image, before closing the handle.
 578    *
 579    * @throws LibGuestFSException
 580    */
 581   public void sync ()
 582     throws LibGuestFSException
 583   {
 584     if (g == 0)
 585       throw new LibGuestFSException ("sync: handle is closed");
 586     _sync (g);
 587   }
 588   private native void _sync (long g)
 589     throws LibGuestFSException;
 590
 591   /**
 592    * update file timestamps or create a new file
 593    *
 594    * Touch acts like the touch(1) command. It can be used to
 595    * update the timestamps on a file, or, if the file does
 596    * not exist, to create a new zero-length file.
 597    *
 598    * @throws LibGuestFSException
 599    */
 600   public void touch (String path)
 601     throws LibGuestFSException
 602   {
 603     if (g == 0)
 604       throw new LibGuestFSException ("touch: handle is closed");
 605     _touch (g, path);
 606   }
 607   private native void _touch (long g, String path)
 608     throws LibGuestFSException;
 609
 610   /**
 611    * list the contents of a file
 612    *
 613    * Return the contents of the file named "path".
 614    *
 615    * Note that this function cannot correctly handle binary
 616    * files (specifically, files containing "\0" character
 617    * which is treated as end of string). For those you need
 618    * to use the "g.download" function which has a more
 619    * complex interface.
 620    *
 621    * Because of the message protocol, there is a transfer
 622    * limit of somewhere between 2MB and 4MB. To transfer
 623    * large files you should use FTP.
 624    *
 625    * @throws LibGuestFSException
 626    */
 627   public String cat (String path)
 628     throws LibGuestFSException
 629   {
 630     if (g == 0)
 631       throw new LibGuestFSException ("cat: handle is closed");
 632     return _cat (g, path);
 633   }
 634   private native String _cat (long g, String path)
 635     throws LibGuestFSException;
 636
 637   /**
 638    * list the files in a directory (long format)
 639    *
 640    * List the files in "directory" (relative to the root
 641    * directory, there is no cwd) in the format of 'ls -la'.
 642    *
 643    * This command is mostly useful for interactive sessions.
 644    * It is *not* intended that you try to parse the output
 645    * string.
 646    *
 647    * @throws LibGuestFSException
 648    */
 649   public String ll (String directory)
 650     throws LibGuestFSException
 651   {
 652     if (g == 0)
 653       throw new LibGuestFSException ("ll: handle is closed");
 654     return _ll (g, directory);
 655   }
 656   private native String _ll (long g, String directory)
 657     throws LibGuestFSException;
 658
 659   /**
 660    * list the files in a directory
 661    *
 662    * List the files in "directory" (relative to the root
 663    * directory, there is no cwd). The '.' and '..' entries
 664    * are not returned, but hidden files are shown.
 665    *
 666    * This command is mostly useful for interactive sessions.
 667    * Programs should probably use "g.readdir" instead.
 668    *
 669    * @throws LibGuestFSException
 670    */
 671   public String[] ls (String directory)
 672     throws LibGuestFSException
 673   {
 674     if (g == 0)
 675       throw new LibGuestFSException ("ls: handle is closed");
 676     return _ls (g, directory);
 677   }
 678   private native String[] _ls (long g, String directory)
 679     throws LibGuestFSException;
 680
 681   /**
 682    * list the block devices
 683    *
 684    * List all the block devices.
 685    *
 686    * The full block device names are returned, eg. "/dev/sda"
 687    *
 688    * @throws LibGuestFSException
 689    */
 690   public String[] list_devices ()
 691     throws LibGuestFSException
 692   {
 693     if (g == 0)
 694       throw new LibGuestFSException ("list_devices: handle is closed");
 695     return _list_devices (g);
 696   }
 697   private native String[] _list_devices (long g)
 698     throws LibGuestFSException;
 699
 700   /**
 701    * list the partitions
 702    *
 703    * List all the partitions detected on all block devices.
 704    *
 705    * The full partition device names are returned, eg.
 706    * "/dev/sda1"
 707    *
 708    * This does not return logical volumes. For that you will
 709    * need to call "g.lvs".
 710    *
 711    * @throws LibGuestFSException
 712    */
 713   public String[] list_partitions ()
 714     throws LibGuestFSException
 715   {
 716     if (g == 0)
 717       throw new LibGuestFSException ("list_partitions: handle is closed");
 718     return _list_partitions (g);
 719   }
 720   private native String[] _list_partitions (long g)
 721     throws LibGuestFSException;
 722
 723   /**
 724    * list the LVM physical volumes (PVs)
 725    *
 726    * List all the physical volumes detected. This is the
 727    * equivalent of the pvs(8) command.
 728    *
 729    * This returns a list of just the device names that
 730    * contain PVs (eg. "/dev/sda2").
 731    *
 732    * See also "g.pvs_full".
 733    *
 734    * @throws LibGuestFSException
 735    */
 736   public String[] pvs ()
 737     throws LibGuestFSException
 738   {
 739     if (g == 0)
 740       throw new LibGuestFSException ("pvs: handle is closed");
 741     return _pvs (g);
 742   }
 743   private native String[] _pvs (long g)
 744     throws LibGuestFSException;
 745
 746   /**
 747    * list the LVM volume groups (VGs)
 748    *
 749    * List all the volumes groups detected. This is the
 750    * equivalent of the vgs(8) command.
 751    *
 752    * This returns a list of just the volume group names that
 753    * were detected (eg. "VolGroup00").
 754    *
 755    * See also "g.vgs_full".
 756    *
 757    * @throws LibGuestFSException
 758    */
 759   public String[] vgs ()
 760     throws LibGuestFSException
 761   {
 762     if (g == 0)
 763       throw new LibGuestFSException ("vgs: handle is closed");
 764     return _vgs (g);
 765   }
 766   private native String[] _vgs (long g)
 767     throws LibGuestFSException;
 768
 769   /**
 770    * list the LVM logical volumes (LVs)
 771    *
 772    * List all the logical volumes detected. This is the
 773    * equivalent of the lvs(8) command.
 774    *
 775    * This returns a list of the logical volume device names
 776    * (eg. "/dev/VolGroup00/LogVol00").
 777    *
 778    * See also "g.lvs_full".
 779    *
 780    * @throws LibGuestFSException
 781    */
 782   public String[] lvs ()
 783     throws LibGuestFSException
 784   {
 785     if (g == 0)
 786       throw new LibGuestFSException ("lvs: handle is closed");
 787     return _lvs (g);
 788   }
 789   private native String[] _lvs (long g)
 790     throws LibGuestFSException;
 791
 792   /**
 793    * list the LVM physical volumes (PVs)
 794    *
 795    * List all the physical volumes detected. This is the
 796    * equivalent of the pvs(8) command. The "full" version
 797    * includes all fields.
 798    *
 799    * @throws LibGuestFSException
 800    */
 801   public PV[] pvs_full ()
 802     throws LibGuestFSException
 803   {
 804     if (g == 0)
 805       throw new LibGuestFSException ("pvs_full: handle is closed");
 806     return _pvs_full (g);
 807   }
 808   private native PV[] _pvs_full (long g)
 809     throws LibGuestFSException;
 810
 811   /**
 812    * list the LVM volume groups (VGs)
 813    *
 814    * List all the volumes groups detected. This is the
 815    * equivalent of the vgs(8) command. The "full" version
 816    * includes all fields.
 817    *
 818    * @throws LibGuestFSException
 819    */
 820   public VG[] vgs_full ()
 821     throws LibGuestFSException
 822   {
 823     if (g == 0)
 824       throw new LibGuestFSException ("vgs_full: handle is closed");
 825     return _vgs_full (g);
 826   }
 827   private native VG[] _vgs_full (long g)
 828     throws LibGuestFSException;
 829
 830   /**
 831    * list the LVM logical volumes (LVs)
 832    *
 833    * List all the logical volumes detected. This is the
 834    * equivalent of the lvs(8) command. The "full" version
 835    * includes all fields.
 836    *
 837    * @throws LibGuestFSException
 838    */
 839   public LV[] lvs_full ()
 840     throws LibGuestFSException
 841   {
 842     if (g == 0)
 843       throw new LibGuestFSException ("lvs_full: handle is closed");
 844     return _lvs_full (g);
 845   }
 846   private native LV[] _lvs_full (long g)
 847     throws LibGuestFSException;
 848
 849   /**
 850    * read file as lines
 851    *
 852    * Return the contents of the file named "path".
 853    *
 854    * The file contents are returned as a list of lines.
 855    * Trailing "LF" and "CRLF" character sequences are *not*
 856    * returned.
 857    *
 858    * Note that this function cannot correctly handle binary
 859    * files (specifically, files containing "\0" character
 860    * which is treated as end of line). For those you need to
 861    * use the "g.read_file" function which has a more complex
 862    * interface.
 863    *
 864    * @throws LibGuestFSException
 865    */
 866   public String[] read_lines (String path)
 867     throws LibGuestFSException
 868   {
 869     if (g == 0)
 870       throw new LibGuestFSException ("read_lines: handle is closed");
 871     return _read_lines (g, path);
 872   }
 873   private native String[] _read_lines (long g, String path)
 874     throws LibGuestFSException;
 875
 876   /**
 877    * create a new Augeas handle
 878    *
 879    * Create a new Augeas handle for editing configuration
 880    * files. If there was any previous Augeas handle
 881    * associated with this guestfs session, then it is closed.
 882    *
 883    * You must call this before using any other "g.aug_*"
 884    * commands.
 885    *
 886    * "root" is the filesystem root. "root" must not be NULL,
 887    * use "/" instead.
 888    *
 889    * The flags are the same as the flags defined in
 890    * <augeas.h>, the logical *or* of the following integers:
 891    *
 892    * "AUG_SAVE_BACKUP" = 1
 893    * Keep the original file with a ".augsave" extension.
 894    *
 895    * "AUG_SAVE_NEWFILE" = 2
 896    * Save changes into a file with extension ".augnew",
 897    * and do not overwrite original. Overrides
 898    * "AUG_SAVE_BACKUP".
 899    *
 900    * "AUG_TYPE_CHECK" = 4
 901    * Typecheck lenses (can be expensive).
 902    *
 903    * "AUG_NO_STDINC" = 8
 904    * Do not use standard load path for modules.
 905    *
 906    * "AUG_SAVE_NOOP" = 16
 907    * Make save a no-op, just record what would have been
 908    * changed.
 909    *
 910    * "AUG_NO_LOAD" = 32
 911    * Do not load the tree in "g.aug_init".
 912    *
 913    * To close the handle, you can call "g.aug_close".
 914    *
 915    * To find out more about Augeas, see <http://augeas.net/>.
 916    *
 917    * @throws LibGuestFSException
 918    */
 919   public void aug_init (String root, int flags)
 920     throws LibGuestFSException
 921   {
 922     if (g == 0)
 923       throw new LibGuestFSException ("aug_init: handle is closed");
 924     _aug_init (g, root, flags);
 925   }
 926   private native void _aug_init (long g, String root, int flags)
 927     throws LibGuestFSException;
 928
 929   /**
 930    * close the current Augeas handle
 931    *
 932    * Close the current Augeas handle and free up any
 933    * resources used by it. After calling this, you have to
 934    * call "g.aug_init" again before you can use any other
 935    * Augeas functions.
 936    *
 937    * @throws LibGuestFSException
 938    */
 939   public void aug_close ()
 940     throws LibGuestFSException
 941   {
 942     if (g == 0)
 943       throw new LibGuestFSException ("aug_close: handle is closed");
 944     _aug_close (g);
 945   }
 946   private native void _aug_close (long g)
 947     throws LibGuestFSException;
 948
 949   /**
 950    * define an Augeas variable
 951    *
 952    * Defines an Augeas variable "name" whose value is the
 953    * result of evaluating "expr". If "expr" is NULL, then
 954    * "name" is undefined.
 955    *
 956    * On success this returns the number of nodes in "expr",
 957    * or 0 if "expr" evaluates to something which is not a
 958    * nodeset.
 959    *
 960    * @throws LibGuestFSException
 961    */
 962   public int aug_defvar (String name, String expr)
 963     throws LibGuestFSException
 964   {
 965     if (g == 0)
 966       throw new LibGuestFSException ("aug_defvar: handle is closed");
 967     return _aug_defvar (g, name, expr);
 968   }
 969   private native int _aug_defvar (long g, String name, String expr)
 970     throws LibGuestFSException;
 971
 972   /**
 973    * define an Augeas node
 974    *
 975    * Defines a variable "name" whose value is the result of
 976    * evaluating "expr".
 977    *
 978    * If "expr" evaluates to an empty nodeset, a node is
 979    * created, equivalent to calling "g.aug_set" "expr",
 980    * "value". "name" will be the nodeset containing that
 981    * single node.
 982    *
 983    * On success this returns a pair containing the number of
 984    * nodes in the nodeset, and a boolean flag if a node was
 985    * created.
 986    *
 987    * @throws LibGuestFSException
 988    */
 989   public IntBool aug_defnode (String name, String expr, String val)
 990     throws LibGuestFSException
 991   {
 992     if (g == 0)
 993       throw new LibGuestFSException ("aug_defnode: handle is closed");
 994     return _aug_defnode (g, name, expr, val);
 995   }
 996   private native IntBool _aug_defnode (long g, String name, String expr, String val)
 997     throws LibGuestFSException;
 998
 999   /**
1000    * look up the value of an Augeas path
1001    *
1002    * Look up the value associated with "path". If "path"
1003    * matches exactly one node, the "value" is returned.
1004    *
1005    * @throws LibGuestFSException
1006    */
1007   public String aug_get (String path)
1008     throws LibGuestFSException
1009   {
1010     if (g == 0)
1011       throw new LibGuestFSException ("aug_get: handle is closed");
1012     return _aug_get (g, path);
1013   }
1014   private native String _aug_get (long g, String path)
1015     throws LibGuestFSException;
1016
1017   /**
1018    * set Augeas path to value
1019    *
1020    * Set the value associated with "path" to "value".
1021    *
1022    * @throws LibGuestFSException
1023    */
1024   public void aug_set (String path, String val)
1025     throws LibGuestFSException
1026   {
1027     if (g == 0)
1028       throw new LibGuestFSException ("aug_set: handle is closed");
1029     _aug_set (g, path, val);
1030   }
1031   private native void _aug_set (long g, String path, String val)
1032     throws LibGuestFSException;
1033
1034   /**
1035    * insert a sibling Augeas node
1036    *
1037    * Create a new sibling "label" for "path", inserting it
1038    * into the tree before or after "path" (depending on the
1039    * boolean flag "before").
1040    *
1041    * "path" must match exactly one existing node in the tree,
1042    * and "label" must be a label, ie. not contain "/", "*" or
1043    * end with a bracketed index "[N]".
1044    *
1045    * @throws LibGuestFSException
1046    */
1047   public void aug_insert (String path, String label, boolean before)
1048     throws LibGuestFSException
1049   {
1050     if (g == 0)
1051       throw new LibGuestFSException ("aug_insert: handle is closed");
1052     _aug_insert (g, path, label, before);
1053   }
1054   private native void _aug_insert (long g, String path, String label, boolean before)
1055     throws LibGuestFSException;
1056
1057   /**
1058    * remove an Augeas path
1059    *
1060    * Remove "path" and all of its children.
1061    *
1062    * On success this returns the number of entries which were
1063    * removed.
1064    *
1065    * @throws LibGuestFSException
1066    */
1067   public int aug_rm (String path)
1068     throws LibGuestFSException
1069   {
1070     if (g == 0)
1071       throw new LibGuestFSException ("aug_rm: handle is closed");
1072     return _aug_rm (g, path);
1073   }
1074   private native int _aug_rm (long g, String path)
1075     throws LibGuestFSException;
1076
1077   /**
1078    * move Augeas node
1079    *
1080    * Move the node "src" to "dest". "src" must match exactly
1081    * one node. "dest" is overwritten if it exists.
1082    *
1083    * @throws LibGuestFSException
1084    */
1085   public void aug_mv (String src, String dest)
1086     throws LibGuestFSException
1087   {
1088     if (g == 0)
1089       throw new LibGuestFSException ("aug_mv: handle is closed");
1090     _aug_mv (g, src, dest);
1091   }
1092   private native void _aug_mv (long g, String src, String dest)
1093     throws LibGuestFSException;
1094
1095   /**
1096    * return Augeas nodes which match path
1097    *
1098    * Returns a list of paths which match the path expression
1099    * "path". The returned paths are sufficiently qualified so
1100    * that they match exactly one node in the current tree.
1101    *
1102    * @throws LibGuestFSException
1103    */
1104   public String[] aug_match (String path)
1105     throws LibGuestFSException
1106   {
1107     if (g == 0)
1108       throw new LibGuestFSException ("aug_match: handle is closed");
1109     return _aug_match (g, path);
1110   }
1111   private native String[] _aug_match (long g, String path)
1112     throws LibGuestFSException;
1113
1114   /**
1115    * write all pending Augeas changes to disk
1116    *
1117    * This writes all pending changes to disk.
1118    *
1119    * The flags which were passed to "g.aug_init" affect
1120    * exactly how files are saved.
1121    *
1122    * @throws LibGuestFSException
1123    */
1124   public void aug_save ()
1125     throws LibGuestFSException
1126   {
1127     if (g == 0)
1128       throw new LibGuestFSException ("aug_save: handle is closed");
1129     _aug_save (g);
1130   }
1131   private native void _aug_save (long g)
1132     throws LibGuestFSException;
1133
1134   /**
1135    * load files into the tree
1136    *
1137    * Load files into the tree.
1138    *
1139    * See "aug_load" in the Augeas documentation for the full
1140    * gory details.
1141    *
1142    * @throws LibGuestFSException
1143    */
1144   public void aug_load ()
1145     throws LibGuestFSException
1146   {
1147     if (g == 0)
1148       throw new LibGuestFSException ("aug_load: handle is closed");
1149     _aug_load (g);
1150   }
1151   private native void _aug_load (long g)
1152     throws LibGuestFSException;
1153
1154   /**
1155    * list Augeas nodes under a path
1156    *
1157    * This is just a shortcut for listing "g.aug_match"
1158    * "path/*" and sorting the resulting nodes into
1159    * alphabetical order.
1160    *
1161    * @throws LibGuestFSException
1162    */
1163   public String[] aug_ls (String path)
1164     throws LibGuestFSException
1165   {
1166     if (g == 0)
1167       throw new LibGuestFSException ("aug_ls: handle is closed");
1168     return _aug_ls (g, path);
1169   }
1170   private native String[] _aug_ls (long g, String path)
1171     throws LibGuestFSException;
1172
1173   /**
1174    * remove a file
1175    *
1176    * Remove the single file "path".
1177    *
1178    * @throws LibGuestFSException
1179    */
1180   public void rm (String path)
1181     throws LibGuestFSException
1182   {
1183     if (g == 0)
1184       throw new LibGuestFSException ("rm: handle is closed");
1185     _rm (g, path);
1186   }
1187   private native void _rm (long g, String path)
1188     throws LibGuestFSException;
1189
1190   /**
1191    * remove a directory
1192    *
1193    * Remove the single directory "path".
1194    *
1195    * @throws LibGuestFSException
1196    */
1197   public void rmdir (String path)
1198     throws LibGuestFSException
1199   {
1200     if (g == 0)
1201       throw new LibGuestFSException ("rmdir: handle is closed");
1202     _rmdir (g, path);
1203   }
1204   private native void _rmdir (long g, String path)
1205     throws LibGuestFSException;
1206
1207   /**
1208    * remove a file or directory recursively
1209    *
1210    * Remove the file or directory "path", recursively
1211    * removing the contents if its a directory. This is like
1212    * the "rm -rf" shell command.
1213    *
1214    * @throws LibGuestFSException
1215    */
1216   public void rm_rf (String path)
1217     throws LibGuestFSException
1218   {
1219     if (g == 0)
1220       throw new LibGuestFSException ("rm_rf: handle is closed");
1221     _rm_rf (g, path);
1222   }
1223   private native void _rm_rf (long g, String path)
1224     throws LibGuestFSException;
1225
1226   /**
1227    * create a directory
1228    *
1229    * Create a directory named "path".
1230    *
1231    * @throws LibGuestFSException
1232    */
1233   public void mkdir (String path)
1234     throws LibGuestFSException
1235   {
1236     if (g == 0)
1237       throw new LibGuestFSException ("mkdir: handle is closed");
1238     _mkdir (g, path);
1239   }
1240   private native void _mkdir (long g, String path)
1241     throws LibGuestFSException;
1242
1243   /**
1244    * create a directory and parents
1245    *
1246    * Create a directory named "path", creating any parent
1247    * directories as necessary. This is like the "mkdir -p"
1248    * shell command.
1249    *
1250    * @throws LibGuestFSException
1251    */
1252   public void mkdir_p (String path)
1253     throws LibGuestFSException
1254   {
1255     if (g == 0)
1256       throw new LibGuestFSException ("mkdir_p: handle is closed");
1257     _mkdir_p (g, path);
1258   }
1259   private native void _mkdir_p (long g, String path)
1260     throws LibGuestFSException;
1261
1262   /**
1263    * change file mode
1264    *
1265    * Change the mode (permissions) of "path" to "mode". Only
1266    * numeric modes are supported.
1267    *
1268    * @throws LibGuestFSException
1269    */
1270   public void chmod (int mode, String path)
1271     throws LibGuestFSException
1272   {
1273     if (g == 0)
1274       throw new LibGuestFSException ("chmod: handle is closed");
1275     _chmod (g, mode, path);
1276   }
1277   private native void _chmod (long g, int mode, String path)
1278     throws LibGuestFSException;
1279
1280   /**
1281    * change file owner and group
1282    *
1283    * Change the file owner to "owner" and group to "group".
1284    *
1285    * Only numeric uid and gid are supported. If you want to
1286    * use names, you will need to locate and parse the
1287    * password file yourself (Augeas support makes this
1288    * relatively easy).
1289    *
1290    * @throws LibGuestFSException
1291    */
1292   public void chown (int owner, int group, String path)
1293     throws LibGuestFSException
1294   {
1295     if (g == 0)
1296       throw new LibGuestFSException ("chown: handle is closed");
1297     _chown (g, owner, group, path);
1298   }
1299   private native void _chown (long g, int owner, int group, String path)
1300     throws LibGuestFSException;
1301
1302   /**
1303    * test if file or directory exists
1304    *
1305    * This returns "true" if and only if there is a file,
1306    * directory (or anything) with the given "path" name.
1307    *
1308    * See also "g.is_file", "g.is_dir", "g.stat".
1309    *
1310    * @throws LibGuestFSException
1311    */
1312   public boolean exists (String path)
1313     throws LibGuestFSException
1314   {
1315     if (g == 0)
1316       throw new LibGuestFSException ("exists: handle is closed");
1317     return _exists (g, path);
1318   }
1319   private native boolean _exists (long g, String path)
1320     throws LibGuestFSException;
1321
1322   /**
1323    * test if file exists
1324    *
1325    * This returns "true" if and only if there is a file with
1326    * the given "path" name. Note that it returns false for
1327    * other objects like directories.
1328    *
1329    * See also "g.stat".
1330    *
1331    * @throws LibGuestFSException
1332    */
1333   public boolean is_file (String path)
1334     throws LibGuestFSException
1335   {
1336     if (g == 0)
1337       throw new LibGuestFSException ("is_file: handle is closed");
1338     return _is_file (g, path);
1339   }
1340   private native boolean _is_file (long g, String path)
1341     throws LibGuestFSException;
1342
1343   /**
1344    * test if file exists
1345    *
1346    * This returns "true" if and only if there is a directory
1347    * with the given "path" name. Note that it returns false
1348    * for other objects like files.
1349    *
1350    * See also "g.stat".
1351    *
1352    * @throws LibGuestFSException
1353    */
1354   public boolean is_dir (String path)
1355     throws LibGuestFSException
1356   {
1357     if (g == 0)
1358       throw new LibGuestFSException ("is_dir: handle is closed");
1359     return _is_dir (g, path);
1360   }
1361   private native boolean _is_dir (long g, String path)
1362     throws LibGuestFSException;
1363
1364   /**
1365    * create an LVM physical volume
1366    *
1367    * This creates an LVM physical volume on the named
1368    * "device", where "device" should usually be a partition
1369    * name such as "/dev/sda1".
1370    *
1371    * @throws LibGuestFSException
1372    */
1373   public void pvcreate (String device)
1374     throws LibGuestFSException
1375   {
1376     if (g == 0)
1377       throw new LibGuestFSException ("pvcreate: handle is closed");
1378     _pvcreate (g, device);
1379   }
1380   private native void _pvcreate (long g, String device)
1381     throws LibGuestFSException;
1382
1383   /**
1384    * create an LVM volume group
1385    *
1386    * This creates an LVM volume group called "volgroup" from
1387    * the non-empty list of physical volumes "physvols".
1388    *
1389    * @throws LibGuestFSException
1390    */
1391   public void vgcreate (String volgroup, String[] physvols)
1392     throws LibGuestFSException
1393   {
1394     if (g == 0)
1395       throw new LibGuestFSException ("vgcreate: handle is closed");
1396     _vgcreate (g, volgroup, physvols);
1397   }
1398   private native void _vgcreate (long g, String volgroup, String[] physvols)
1399     throws LibGuestFSException;
1400
1401   /**
1402    * create an LVM volume group
1403    *
1404    * This creates an LVM volume group called "logvol" on the
1405    * volume group "volgroup", with "size" megabytes.
1406    *
1407    * @throws LibGuestFSException
1408    */
1409   public void lvcreate (String logvol, String volgroup, int mbytes)
1410     throws LibGuestFSException
1411   {
1412     if (g == 0)
1413       throw new LibGuestFSException ("lvcreate: handle is closed");
1414     _lvcreate (g, logvol, volgroup, mbytes);
1415   }
1416   private native void _lvcreate (long g, String logvol, String volgroup, int mbytes)
1417     throws LibGuestFSException;
1418
1419   /**
1420    * make a filesystem
1421    *
1422    * This creates a filesystem on "device" (usually a
1423    * partition of LVM logical volume). The filesystem type is
1424    * "fstype", for example "ext3".
1425    *
1426    * @throws LibGuestFSException
1427    */
1428   public void mkfs (String fstype, String device)
1429     throws LibGuestFSException
1430   {
1431     if (g == 0)
1432       throw new LibGuestFSException ("mkfs: handle is closed");
1433     _mkfs (g, fstype, device);
1434   }
1435   private native void _mkfs (long g, String fstype, String device)
1436     throws LibGuestFSException;
1437
1438   /**
1439    * create partitions on a block device
1440    *
1441    * This is a direct interface to the sfdisk(8) program for
1442    * creating partitions on block devices.
1443    *
1444    * "device" should be a block device, for example
1445    * "/dev/sda".
1446    *
1447    * "cyls", "heads" and "sectors" are the number of
1448    * cylinders, heads and sectors on the device, which are
1449    * passed directly to sfdisk as the *-C*, *-H* and *-S*
1450    * parameters. If you pass 0 for any of these, then the
1451    * corresponding parameter is omitted. Usually for 'large'
1452    * disks, you can just pass 0 for these, but for small
1453    * (floppy-sized) disks, sfdisk (or rather, the kernel)
1454    * cannot work out the right geometry and you will need to
1455    * tell it.
1456    *
1457    * "lines" is a list of lines that we feed to "sfdisk". For
1458    * more information refer to the sfdisk(8) manpage.
1459    *
1460    * To create a single partition occupying the whole disk,
1461    * you would pass "lines" as a single element list, when
1462    * the single element being the string "," (comma).
1463    *
1464    * This command is dangerous. Without careful use you can
1465    * easily destroy all your data.
1466    *
1467    * @throws LibGuestFSException
1468    */
1469   public void sfdisk (String device, int cyls, int heads, int sectors, String[] lines)
1470     throws LibGuestFSException
1471   {
1472     if (g == 0)
1473       throw new LibGuestFSException ("sfdisk: handle is closed");
1474     _sfdisk (g, device, cyls, heads, sectors, lines);
1475   }
1476   private native void _sfdisk (long g, String device, int cyls, int heads, int sectors, String[] lines)
1477     throws LibGuestFSException;
1478
1479   /**
1480    * create a file
1481    *
1482    * This call creates a file called "path". The contents of
1483    * the file is the string "content" (which can contain any
1484    * 8 bit data), with length "size".
1485    *
1486    * As a special case, if "size" is 0 then the length is
1487    * calculated using "strlen" (so in this case the content
1488    * cannot contain embedded ASCII NULs).
1489    *
1490    * Because of the message protocol, there is a transfer
1491    * limit of somewhere between 2MB and 4MB. To transfer
1492    * large files you should use FTP.
1493    *
1494    * @throws LibGuestFSException
1495    */
1496   public void write_file (String path, String content, int size)
1497     throws LibGuestFSException
1498   {
1499     if (g == 0)
1500       throw new LibGuestFSException ("write_file: handle is closed");
1501     _write_file (g, path, content, size);
1502   }
1503   private native void _write_file (long g, String path, String content, int size)
1504     throws LibGuestFSException;
1505
1506   /**
1507    * unmount a filesystem
1508    *
1509    * This unmounts the given filesystem. The filesystem may
1510    * be specified either by its mountpoint (path) or the
1511    * device which contains the filesystem.
1512    *
1513    * @throws LibGuestFSException
1514    */
1515   public void umount (String pathordevice)
1516     throws LibGuestFSException
1517   {
1518     if (g == 0)
1519       throw new LibGuestFSException ("umount: handle is closed");
1520     _umount (g, pathordevice);
1521   }
1522   private native void _umount (long g, String pathordevice)
1523     throws LibGuestFSException;
1524
1525   /**
1526    * show mounted filesystems
1527    *
1528    * This returns the list of currently mounted filesystems.
1529    * It returns the list of devices (eg. "/dev/sda1",
1530    * "/dev/VG/LV").
1531    *
1532    * Some internal mounts are not shown.
1533    *
1534    * @throws LibGuestFSException
1535    */
1536   public String[] mounts ()
1537     throws LibGuestFSException
1538   {
1539     if (g == 0)
1540       throw new LibGuestFSException ("mounts: handle is closed");
1541     return _mounts (g);
1542   }
1543   private native String[] _mounts (long g)
1544     throws LibGuestFSException;
1545
1546   /**
1547    * unmount all filesystems
1548    *
1549    * This unmounts all mounted filesystems.
1550    *
1551    * Some internal mounts are not unmounted by this call.
1552    *
1553    * @throws LibGuestFSException
1554    */
1555   public void umount_all ()
1556     throws LibGuestFSException
1557   {
1558     if (g == 0)
1559       throw new LibGuestFSException ("umount_all: handle is closed");
1560     _umount_all (g);
1561   }
1562   private native void _umount_all (long g)
1563     throws LibGuestFSException;
1564
1565   /**
1566    * remove all LVM LVs, VGs and PVs
1567    *
1568    * This command removes all LVM logical volumes, volume
1569    * groups and physical volumes.
1570    *
1571    * This command is dangerous. Without careful use you can
1572    * easily destroy all your data.
1573    *
1574    * @throws LibGuestFSException
1575    */
1576   public void lvm_remove_all ()
1577     throws LibGuestFSException
1578   {
1579     if (g == 0)
1580       throw new LibGuestFSException ("lvm_remove_all: handle is closed");
1581     _lvm_remove_all (g);
1582   }
1583   private native void _lvm_remove_all (long g)
1584     throws LibGuestFSException;
1585
1586   /**
1587    * determine file type
1588    *
1589    * This call uses the standard file(1) command to determine
1590    * the type or contents of the file. This also works on
1591    * devices, for example to find out whether a partition
1592    * contains a filesystem.
1593    *
1594    * The exact command which runs is "file -bsL path". Note
1595    * in particular that the filename is not prepended to the
1596    * output (the "-b" option).
1597    *
1598    * @throws LibGuestFSException
1599    */
1600   public String file (String path)
1601     throws LibGuestFSException
1602   {
1603     if (g == 0)
1604       throw new LibGuestFSException ("file: handle is closed");
1605     return _file (g, path);
1606   }
1607   private native String _file (long g, String path)
1608     throws LibGuestFSException;
1609
1610   /**
1611    * run a command from the guest filesystem
1612    *
1613    * This call runs a command from the guest filesystem. The
1614    * filesystem must be mounted, and must contain a
1615    * compatible operating system (ie. something Linux, with
1616    * the same or compatible processor architecture).
1617    *
1618    * The single parameter is an argv-style list of arguments.
1619    * The first element is the name of the program to run.
1620    * Subsequent elements are parameters. The list must be
1621    * non-empty (ie. must contain a program name).
1622    *
1623    * The $PATH environment variable will contain at least
1624    * "/usr/bin" and "/bin". If you require a program from
1625    * another location, you should provide the full path in
1626    * the first parameter.
1627    *
1628    * Shared libraries and data files required by the program
1629    * must be available on filesystems which are mounted in
1630    * the correct places. It is the caller's responsibility to
1631    * ensure all filesystems that are needed are mounted at
1632    * the right locations.
1633    *
1634    * @throws LibGuestFSException
1635    */
1636   public String command (String[] arguments)
1637     throws LibGuestFSException
1638   {
1639     if (g == 0)
1640       throw new LibGuestFSException ("command: handle is closed");
1641     return _command (g, arguments);
1642   }
1643   private native String _command (long g, String[] arguments)
1644     throws LibGuestFSException;
1645
1646   /**
1647    * run a command, returning lines
1648    *
1649    * This is the same as "g.command", but splits the result
1650    * into a list of lines.
1651    *
1652    * @throws LibGuestFSException
1653    */
1654   public String[] command_lines (String[] arguments)
1655     throws LibGuestFSException
1656   {
1657     if (g == 0)
1658       throw new LibGuestFSException ("command_lines: handle is closed");
1659     return _command_lines (g, arguments);
1660   }
1661   private native String[] _command_lines (long g, String[] arguments)
1662     throws LibGuestFSException;
1663
1664   /**
1665    * get file information
1666    *
1667    * Returns file information for the given "path".
1668    *
1669    * This is the same as the stat(2) system call.
1670    *
1671    * @throws LibGuestFSException
1672    */
1673   public Stat stat (String path)
1674     throws LibGuestFSException
1675   {
1676     if (g == 0)
1677       throw new LibGuestFSException ("stat: handle is closed");
1678     return _stat (g, path);
1679   }
1680   private native Stat _stat (long g, String path)
1681     throws LibGuestFSException;
1682
1683   /**
1684    * get file information for a symbolic link
1685    *
1686    * Returns file information for the given "path".
1687    *
1688    * This is the same as "g.stat" except that if "path" is a
1689    * symbolic link, then the link is stat-ed, not the file it
1690    * refers to.
1691    *
1692    * This is the same as the lstat(2) system call.
1693    *
1694    * @throws LibGuestFSException
1695    */
1696   public Stat lstat (String path)
1697     throws LibGuestFSException
1698   {
1699     if (g == 0)
1700       throw new LibGuestFSException ("lstat: handle is closed");
1701     return _lstat (g, path);
1702   }
1703   private native Stat _lstat (long g, String path)
1704     throws LibGuestFSException;
1705
1706   /**
1707    * get file system statistics
1708    *
1709    * Returns file system statistics for any mounted file
1710    * system. "path" should be a file or directory in the
1711    * mounted file system (typically it is the mount point
1712    * itself, but it doesn't need to be).
1713    *
1714    * This is the same as the statvfs(2) system call.
1715    *
1716    * @throws LibGuestFSException
1717    */
1718   public StatVFS statvfs (String path)
1719     throws LibGuestFSException
1720   {
1721     if (g == 0)
1722       throw new LibGuestFSException ("statvfs: handle is closed");
1723     return _statvfs (g, path);
1724   }
1725   private native StatVFS _statvfs (long g, String path)
1726     throws LibGuestFSException;
1727
1728   /**
1729    * get ext2/ext3/ext4 superblock details
1730    *
1731    * This returns the contents of the ext2, ext3 or ext4
1732    * filesystem superblock on "device".
1733    *
1734    * It is the same as running "tune2fs -l device". See
1735    * tune2fs(8) manpage for more details. The list of fields
1736    * returned isn't clearly defined, and depends on both the
1737    * version of "tune2fs" that libguestfs was built against,
1738    * and the filesystem itself.
1739    *
1740    * @throws LibGuestFSException
1741    */
1742   public HashMap<String,String> tune2fs_l (String device)
1743     throws LibGuestFSException
1744   {
1745     if (g == 0)
1746       throw new LibGuestFSException ("tune2fs_l: handle is closed");
1747     return _tune2fs_l (g, device);
1748   }
1749   private native HashMap<String,String> _tune2fs_l (long g, String device)
1750     throws LibGuestFSException;
1751
1752   /**
1753    * set block device to read-only
1754    *
1755    * Sets the block device named "device" to read-only.
1756    *
1757    * This uses the blockdev(8) command.
1758    *
1759    * @throws LibGuestFSException
1760    */
1761   public void blockdev_setro (String device)
1762     throws LibGuestFSException
1763   {
1764     if (g == 0)
1765       throw new LibGuestFSException ("blockdev_setro: handle is closed");
1766     _blockdev_setro (g, device);
1767   }
1768   private native void _blockdev_setro (long g, String device)
1769     throws LibGuestFSException;
1770
1771   /**
1772    * set block device to read-write
1773    *
1774    * Sets the block device named "device" to read-write.
1775    *
1776    * This uses the blockdev(8) command.
1777    *
1778    * @throws LibGuestFSException
1779    */
1780   public void blockdev_setrw (String device)
1781     throws LibGuestFSException
1782   {
1783     if (g == 0)
1784       throw new LibGuestFSException ("blockdev_setrw: handle is closed");
1785     _blockdev_setrw (g, device);
1786   }
1787   private native void _blockdev_setrw (long g, String device)
1788     throws LibGuestFSException;
1789
1790   /**
1791    * is block device set to read-only
1792    *
1793    * Returns a boolean indicating if the block device is
1794    * read-only (true if read-only, false if not).
1795    *
1796    * This uses the blockdev(8) command.
1797    *
1798    * @throws LibGuestFSException
1799    */
1800   public boolean blockdev_getro (String device)
1801     throws LibGuestFSException
1802   {
1803     if (g == 0)
1804       throw new LibGuestFSException ("blockdev_getro: handle is closed");
1805     return _blockdev_getro (g, device);
1806   }
1807   private native boolean _blockdev_getro (long g, String device)
1808     throws LibGuestFSException;
1809
1810   /**
1811    * get sectorsize of block device
1812    *
1813    * This returns the size of sectors on a block device.
1814    * Usually 512, but can be larger for modern devices.
1815    *
1816    * (Note, this is not the size in sectors, use
1817    * "g.blockdev_getsz" for that).
1818    *
1819    * This uses the blockdev(8) command.
1820    *
1821    * @throws LibGuestFSException
1822    */
1823   public int blockdev_getss (String device)
1824     throws LibGuestFSException
1825   {
1826     if (g == 0)
1827       throw new LibGuestFSException ("blockdev_getss: handle is closed");
1828     return _blockdev_getss (g, device);
1829   }
1830   private native int _blockdev_getss (long g, String device)
1831     throws LibGuestFSException;
1832
1833   /**
1834    * get blocksize of block device
1835    *
1836    * This returns the block size of a device.
1837    *
1838    * (Note this is different from both *size in blocks* and
1839    * *filesystem block size*).
1840    *
1841    * This uses the blockdev(8) command.
1842    *
1843    * @throws LibGuestFSException
1844    */
1845   public int blockdev_getbsz (String device)
1846     throws LibGuestFSException
1847   {
1848     if (g == 0)
1849       throw new LibGuestFSException ("blockdev_getbsz: handle is closed");
1850     return _blockdev_getbsz (g, device);
1851   }
1852   private native int _blockdev_getbsz (long g, String device)
1853     throws LibGuestFSException;
1854
1855   /**
1856    * set blocksize of block device
1857    *
1858    * This sets the block size of a device.
1859    *
1860    * (Note this is different from both *size in blocks* and
1861    * *filesystem block size*).
1862    *
1863    * This uses the blockdev(8) command.
1864    *
1865    * @throws LibGuestFSException
1866    */
1867   public void blockdev_setbsz (String device, int blocksize)
1868     throws LibGuestFSException
1869   {
1870     if (g == 0)
1871       throw new LibGuestFSException ("blockdev_setbsz: handle is closed");
1872     _blockdev_setbsz (g, device, blocksize);
1873   }
1874   private native void _blockdev_setbsz (long g, String device, int blocksize)
1875     throws LibGuestFSException;
1876
1877   /**
1878    * get total size of device in 512-byte sectors
1879    *
1880    * This returns the size of the device in units of 512-byte
1881    * sectors (even if the sectorsize isn't 512 bytes ...
1882    * weird).
1883    *
1884    * See also "g.blockdev_getss" for the real sector size of
1885    * the device, and "g.blockdev_getsize64" for the more
1886    * useful *size in bytes*.
1887    *
1888    * This uses the blockdev(8) command.
1889    *
1890    * @throws LibGuestFSException
1891    */
1892   public long blockdev_getsz (String device)
1893     throws LibGuestFSException
1894   {
1895     if (g == 0)
1896       throw new LibGuestFSException ("blockdev_getsz: handle is closed");
1897     return _blockdev_getsz (g, device);
1898   }
1899   private native long _blockdev_getsz (long g, String device)
1900     throws LibGuestFSException;
1901
1902   /**
1903    * get total size of device in bytes
1904    *
1905    * This returns the size of the device in bytes.
1906    *
1907    * See also "g.blockdev_getsz".
1908    *
1909    * This uses the blockdev(8) command.
1910    *
1911    * @throws LibGuestFSException
1912    */
1913   public long blockdev_getsize64 (String device)
1914     throws LibGuestFSException
1915   {
1916     if (g == 0)
1917       throw new LibGuestFSException ("blockdev_getsize64: handle is closed");
1918     return _blockdev_getsize64 (g, device);
1919   }
1920   private native long _blockdev_getsize64 (long g, String device)
1921     throws LibGuestFSException;
1922
1923   /**
1924    * flush device buffers
1925    *
1926    * This tells the kernel to flush internal buffers
1927    * associated with "device".
1928    *
1929    * This uses the blockdev(8) command.
1930    *
1931    * @throws LibGuestFSException
1932    */
1933   public void blockdev_flushbufs (String device)
1934     throws LibGuestFSException
1935   {
1936     if (g == 0)
1937       throw new LibGuestFSException ("blockdev_flushbufs: handle is closed");
1938     _blockdev_flushbufs (g, device);
1939   }
1940   private native void _blockdev_flushbufs (long g, String device)
1941     throws LibGuestFSException;
1942
1943   /**
1944    * reread partition table
1945    *
1946    * Reread the partition table on "device".
1947    *
1948    * This uses the blockdev(8) command.
1949    *
1950    * @throws LibGuestFSException
1951    */
1952   public void blockdev_rereadpt (String device)
1953     throws LibGuestFSException
1954   {
1955     if (g == 0)
1956       throw new LibGuestFSException ("blockdev_rereadpt: handle is closed");
1957     _blockdev_rereadpt (g, device);
1958   }
1959   private native void _blockdev_rereadpt (long g, String device)
1960     throws LibGuestFSException;
1961
1962   /**
1963    * upload a file from the local machine
1964    *
1965    * Upload local file "filename" to "remotefilename" on the
1966    * filesystem.
1967    *
1968    * "filename" can also be a named pipe.
1969    *
1970    * See also "g.download".
1971    *
1972    * @throws LibGuestFSException
1973    */
1974   public void upload (String filename, String remotefilename)
1975     throws LibGuestFSException
1976   {
1977     if (g == 0)
1978       throw new LibGuestFSException ("upload: handle is closed");
1979     _upload (g, filename, remotefilename);
1980   }
1981   private native void _upload (long g, String filename, String remotefilename)
1982     throws LibGuestFSException;
1983
1984   /**
1985    * download a file to the local machine
1986    *
1987    * Download file "remotefilename" and save it as "filename"
1988    * on the local machine.
1989    *
1990    * "filename" can also be a named pipe.
1991    *
1992    * See also "g.upload", "g.cat".
1993    *
1994    * @throws LibGuestFSException
1995    */
1996   public void download (String remotefilename, String filename)
1997     throws LibGuestFSException
1998   {
1999     if (g == 0)
2000       throw new LibGuestFSException ("download: handle is closed");
2001     _download (g, remotefilename, filename);
2002   }
2003   private native void _download (long g, String remotefilename, String filename)
2004     throws LibGuestFSException;
2005
2006   /**
2007    * compute MD5, SHAx or CRC checksum of file
2008    *
2009    * This call computes the MD5, SHAx or CRC checksum of the
2010    * file named "path".
2011    *
2012    * The type of checksum to compute is given by the
2013    * "csumtype" parameter which must have one of the
2014    * following values:
2015    *
2016    * "crc"
2017    * Compute the cyclic redundancy check (CRC) specified
2018    * by POSIX for the "cksum" command.
2019    *
2020    * "md5"
2021    * Compute the MD5 hash (using the "md5sum" program).
2022    *
2023    * "sha1"
2024    * Compute the SHA1 hash (using the "sha1sum" program).
2025    *
2026    * "sha224"
2027    * Compute the SHA224 hash (using the "sha224sum"
2028    * program).
2029    *
2030    * "sha256"
2031    * Compute the SHA256 hash (using the "sha256sum"
2032    * program).
2033    *
2034    * "sha384"
2035    * Compute the SHA384 hash (using the "sha384sum"
2036    * program).
2037    *
2038    * "sha512"
2039    * Compute the SHA512 hash (using the "sha512sum"
2040    * program).
2041    *
2042    * The checksum is returned as a printable string.
2043    *
2044    * @throws LibGuestFSException
2045    */
2046   public String checksum (String csumtype, String path)
2047     throws LibGuestFSException
2048   {
2049     if (g == 0)
2050       throw new LibGuestFSException ("checksum: handle is closed");
2051     return _checksum (g, csumtype, path);
2052   }
2053   private native String _checksum (long g, String csumtype, String path)
2054     throws LibGuestFSException;
2055
2056   /**
2057    * unpack tarfile to directory
2058    *
2059    * This command uploads and unpacks local file "tarfile"
2060    * (an *uncompressed* tar file) into "directory".
2061    *
2062    * To upload a compressed tarball, use "g.tgz_in".
2063    *
2064    * @throws LibGuestFSException
2065    */
2066   public void tar_in (String tarfile, String directory)
2067     throws LibGuestFSException
2068   {
2069     if (g == 0)
2070       throw new LibGuestFSException ("tar_in: handle is closed");
2071     _tar_in (g, tarfile, directory);
2072   }
2073   private native void _tar_in (long g, String tarfile, String directory)
2074     throws LibGuestFSException;
2075
2076   /**
2077    * pack directory into tarfile
2078    *
2079    * This command packs the contents of "directory" and
2080    * downloads it to local file "tarfile".
2081    *
2082    * To download a compressed tarball, use "g.tgz_out".
2083    *
2084    * @throws LibGuestFSException
2085    */
2086   public void tar_out (String directory, String tarfile)
2087     throws LibGuestFSException
2088   {
2089     if (g == 0)
2090       throw new LibGuestFSException ("tar_out: handle is closed");
2091     _tar_out (g, directory, tarfile);
2092   }
2093   private native void _tar_out (long g, String directory, String tarfile)
2094     throws LibGuestFSException;
2095
2096   /**
2097    * unpack compressed tarball to directory
2098    *
2099    * This command uploads and unpacks local file "tarball" (a
2100    * *gzip compressed* tar file) into "directory".
2101    *
2102    * To upload an uncompressed tarball, use "g.tar_in".
2103    *
2104    * @throws LibGuestFSException
2105    */
2106   public void tgz_in (String tarball, String directory)
2107     throws LibGuestFSException
2108   {
2109     if (g == 0)
2110       throw new LibGuestFSException ("tgz_in: handle is closed");
2111     _tgz_in (g, tarball, directory);
2112   }
2113   private native void _tgz_in (long g, String tarball, String directory)
2114     throws LibGuestFSException;
2115
2116   /**
2117    * pack directory into compressed tarball
2118    *
2119    * This command packs the contents of "directory" and
2120    * downloads it to local file "tarball".
2121    *
2122    * To download an uncompressed tarball, use "g.tar_out".
2123    *
2124    * @throws LibGuestFSException
2125    */
2126   public void tgz_out (String directory, String tarball)
2127     throws LibGuestFSException
2128   {
2129     if (g == 0)
2130       throw new LibGuestFSException ("tgz_out: handle is closed");
2131     _tgz_out (g, directory, tarball);
2132   }
2133   private native void _tgz_out (long g, String directory, String tarball)
2134     throws LibGuestFSException;
2135
2136   /**
2137    * mount a guest disk, read-only
2138    *
2139    * This is the same as the "g.mount" command, but it mounts
2140    * the filesystem with the read-only (*-o ro*) flag.
2141    *
2142    * @throws LibGuestFSException
2143    */
2144   public void mount_ro (String device, String mountpoint)
2145     throws LibGuestFSException
2146   {
2147     if (g == 0)
2148       throw new LibGuestFSException ("mount_ro: handle is closed");
2149     _mount_ro (g, device, mountpoint);
2150   }
2151   private native void _mount_ro (long g, String device, String mountpoint)
2152     throws LibGuestFSException;
2153
2154   /**
2155    * mount a guest disk with mount options
2156    *
2157    * This is the same as the "g.mount" command, but it allows
2158    * you to set the mount options as for the mount(8) *-o*
2159    * flag.
2160    *
2161    * @throws LibGuestFSException
2162    */
2163   public void mount_options (String options, String device, String mountpoint)
2164     throws LibGuestFSException
2165   {
2166     if (g == 0)
2167       throw new LibGuestFSException ("mount_options: handle is closed");
2168     _mount_options (g, options, device, mountpoint);
2169   }
2170   private native void _mount_options (long g, String options, String device, String mountpoint)
2171     throws LibGuestFSException;
2172
2173   /**
2174    * mount a guest disk with mount options and vfstype
2175    *
2176    * This is the same as the "g.mount" command, but it allows
2177    * you to set both the mount options and the vfstype as for
2178    * the mount(8) *-o* and *-t* flags.
2179    *
2180    * @throws LibGuestFSException
2181    */
2182   public void mount_vfs (String options, String vfstype, String device, String mountpoint)
2183     throws LibGuestFSException
2184   {
2185     if (g == 0)
2186       throw new LibGuestFSException ("mount_vfs: handle is closed");
2187     _mount_vfs (g, options, vfstype, device, mountpoint);
2188   }
2189   private native void _mount_vfs (long g, String options, String vfstype, String device, String mountpoint)
2190     throws LibGuestFSException;
2191
2192   /**
2193    * debugging and internals
2194    *
2195    * The "g.debug" command exposes some internals of
2196    * "guestfsd" (the guestfs daemon) that runs inside the
2197    * qemu subprocess.
2198    *
2199    * There is no comprehensive help for this command. You
2200    * have to look at the file "daemon/debug.c" in the
2201    * libguestfs source to find out what you can do.
2202    *
2203    * @throws LibGuestFSException
2204    */
2205   public String debug (String subcmd, String[] extraargs)
2206     throws LibGuestFSException
2207   {
2208     if (g == 0)
2209       throw new LibGuestFSException ("debug: handle is closed");
2210     return _debug (g, subcmd, extraargs);
2211   }
2212   private native String _debug (long g, String subcmd, String[] extraargs)
2213     throws LibGuestFSException;
2214
2215   /**
2216    * remove an LVM logical volume
2217    *
2218    * Remove an LVM logical volume "device", where "device" is
2219    * the path to the LV, such as "/dev/VG/LV".
2220    *
2221    * You can also remove all LVs in a volume group by
2222    * specifying the VG name, "/dev/VG".
2223    *
2224    * @throws LibGuestFSException
2225    */
2226   public void lvremove (String device)
2227     throws LibGuestFSException
2228   {
2229     if (g == 0)
2230       throw new LibGuestFSException ("lvremove: handle is closed");
2231     _lvremove (g, device);
2232   }
2233   private native void _lvremove (long g, String device)
2234     throws LibGuestFSException;
2235
2236   /**
2237    * remove an LVM volume group
2238    *
2239    * Remove an LVM volume group "vgname", (for example "VG").
2240    *
2241    * This also forcibly removes all logical volumes in the
2242    * volume group (if any).
2243    *
2244    * @throws LibGuestFSException
2245    */
2246   public void vgremove (String vgname)
2247     throws LibGuestFSException
2248   {
2249     if (g == 0)
2250       throw new LibGuestFSException ("vgremove: handle is closed");
2251     _vgremove (g, vgname);
2252   }
2253   private native void _vgremove (long g, String vgname)
2254     throws LibGuestFSException;
2255
2256   /**
2257    * remove an LVM physical volume
2258    *
2259    * This wipes a physical volume "device" so that LVM will
2260    * no longer recognise it.
2261    *
2262    * The implementation uses the "pvremove" command which
2263    * refuses to wipe physical volumes that contain any volume
2264    * groups, so you have to remove those first.
2265    *
2266    * @throws LibGuestFSException
2267    */
2268   public void pvremove (String device)
2269     throws LibGuestFSException
2270   {
2271     if (g == 0)
2272       throw new LibGuestFSException ("pvremove: handle is closed");
2273     _pvremove (g, device);
2274   }
2275   private native void _pvremove (long g, String device)
2276     throws LibGuestFSException;
2277
2278   /**
2279    * set the ext2/3/4 filesystem label
2280    *
2281    * This sets the ext2/3/4 filesystem label of the
2282    * filesystem on "device" to "label". Filesystem labels are
2283    * limited to 16 characters.
2284    *
2285    * You can use either "g.tune2fs_l" or "g.get_e2label" to
2286    * return the existing label on a filesystem.
2287    *
2288    * @throws LibGuestFSException
2289    */
2290   public void set_e2label (String device, String label)
2291     throws LibGuestFSException
2292   {
2293     if (g == 0)
2294       throw new LibGuestFSException ("set_e2label: handle is closed");
2295     _set_e2label (g, device, label);
2296   }
2297   private native void _set_e2label (long g, String device, String label)
2298     throws LibGuestFSException;
2299
2300   /**
2301    * get the ext2/3/4 filesystem label
2302    *
2303    * This returns the ext2/3/4 filesystem label of the
2304    * filesystem on "device".
2305    *
2306    * @throws LibGuestFSException
2307    */
2308   public String get_e2label (String device)
2309     throws LibGuestFSException
2310   {
2311     if (g == 0)
2312       throw new LibGuestFSException ("get_e2label: handle is closed");
2313     return _get_e2label (g, device);
2314   }
2315   private native String _get_e2label (long g, String device)
2316     throws LibGuestFSException;
2317
2318   /**
2319    * set the ext2/3/4 filesystem UUID
2320    *
2321    * This sets the ext2/3/4 filesystem UUID of the filesystem
2322    * on "device" to "uuid". The format of the UUID and
2323    * alternatives such as "clear", "random" and "time" are
2324    * described in the tune2fs(8) manpage.
2325    *
2326    * You can use either "g.tune2fs_l" or "g.get_e2uuid" to
2327    * return the existing UUID of a filesystem.
2328    *
2329    * @throws LibGuestFSException
2330    */
2331   public void set_e2uuid (String device, String uuid)
2332     throws LibGuestFSException
2333   {
2334     if (g == 0)
2335       throw new LibGuestFSException ("set_e2uuid: handle is closed");
2336     _set_e2uuid (g, device, uuid);
2337   }
2338   private native void _set_e2uuid (long g, String device, String uuid)
2339     throws LibGuestFSException;
2340
2341   /**
2342    * get the ext2/3/4 filesystem UUID
2343    *
2344    * This returns the ext2/3/4 filesystem UUID of the
2345    * filesystem on "device".
2346    *
2347    * @throws LibGuestFSException
2348    */
2349   public String get_e2uuid (String device)
2350     throws LibGuestFSException
2351   {
2352     if (g == 0)
2353       throw new LibGuestFSException ("get_e2uuid: handle is closed");
2354     return _get_e2uuid (g, device);
2355   }
2356   private native String _get_e2uuid (long g, String device)
2357     throws LibGuestFSException;
2358
2359   /**
2360    * run the filesystem checker
2361    *
2362    * This runs the filesystem checker (fsck) on "device"
2363    * which should have filesystem type "fstype".
2364    *
2365    * The returned integer is the status. See fsck(8) for the
2366    * list of status codes from "fsck".
2367    *
2368    * Notes:
2369    *
2370    * *   Multiple status codes can be summed together.
2371    *
2372    * *   A non-zero return code can mean "success", for
2373    * example if errors have been corrected on the
2374    * filesystem.
2375    *
2376    * *   Checking or repairing NTFS volumes is not supported
2377    * (by linux-ntfs).
2378    *
2379    * This command is entirely equivalent to running "fsck -a
2380    * -t fstype device".
2381    *
2382    * @throws LibGuestFSException
2383    */
2384   public int fsck (String fstype, String device)
2385     throws LibGuestFSException
2386   {
2387     if (g == 0)
2388       throw new LibGuestFSException ("fsck: handle is closed");
2389     return _fsck (g, fstype, device);
2390   }
2391   private native int _fsck (long g, String fstype, String device)
2392     throws LibGuestFSException;
2393
2394   /**
2395    * write zeroes to the device
2396    *
2397    * This command writes zeroes over the first few blocks of
2398    * "device".
2399    *
2400    * How many blocks are zeroed isn't specified (but it's
2401    * *not* enough to securely wipe the device). It should be
2402    * sufficient to remove any partition tables, filesystem
2403    * superblocks and so on.
2404    *
2405    * @throws LibGuestFSException
2406    */
2407   public void zero (String device)
2408     throws LibGuestFSException
2409   {
2410     if (g == 0)
2411       throw new LibGuestFSException ("zero: handle is closed");
2412     _zero (g, device);
2413   }
2414   private native void _zero (long g, String device)
2415     throws LibGuestFSException;
2416
2417   /**
2418    * install GRUB
2419    *
2420    * This command installs GRUB (the Grand Unified
2421    * Bootloader) on "device", with the root directory being
2422    * "root".
2423    *
2424    * @throws LibGuestFSException
2425    */
2426   public void grub_install (String root, String device)
2427     throws LibGuestFSException
2428   {
2429     if (g == 0)
2430       throw new LibGuestFSException ("grub_install: handle is closed");
2431     _grub_install (g, root, device);
2432   }
2433   private native void _grub_install (long g, String root, String device)
2434     throws LibGuestFSException;
2435
2436   /**
2437    * copy a file
2438    *
2439    * This copies a file from "src" to "dest" where "dest" is
2440    * either a destination filename or destination directory.
2441    *
2442    * @throws LibGuestFSException
2443    */
2444   public void cp (String src, String dest)
2445     throws LibGuestFSException
2446   {
2447     if (g == 0)
2448       throw new LibGuestFSException ("cp: handle is closed");
2449     _cp (g, src, dest);
2450   }
2451   private native void _cp (long g, String src, String dest)
2452     throws LibGuestFSException;
2453
2454   /**
2455    * copy a file or directory recursively
2456    *
2457    * This copies a file or directory from "src" to "dest"
2458    * recursively using the "cp -a" command.
2459    *
2460    * @throws LibGuestFSException
2461    */
2462   public void cp_a (String src, String dest)
2463     throws LibGuestFSException
2464   {
2465     if (g == 0)
2466       throw new LibGuestFSException ("cp_a: handle is closed");
2467     _cp_a (g, src, dest);
2468   }
2469   private native void _cp_a (long g, String src, String dest)
2470     throws LibGuestFSException;
2471
2472   /**
2473    * move a file
2474    *
2475    * This moves a file from "src" to "dest" where "dest" is
2476    * either a destination filename or destination directory.
2477    *
2478    * @throws LibGuestFSException
2479    */
2480   public void mv (String src, String dest)
2481     throws LibGuestFSException
2482   {
2483     if (g == 0)
2484       throw new LibGuestFSException ("mv: handle is closed");
2485     _mv (g, src, dest);
2486   }
2487   private native void _mv (long g, String src, String dest)
2488     throws LibGuestFSException;
2489
2490   /**
2491    * drop kernel page cache, dentries and inodes
2492    *
2493    * This instructs the guest kernel to drop its page cache,
2494    * and/or dentries and inode caches. The parameter
2495    * "whattodrop" tells the kernel what precisely to drop,
2496    * see <http://linux-mm.org/Drop_Caches>
2497    *
2498    * Setting "whattodrop" to 3 should drop everything.
2499    *
2500    * This automatically calls sync(2) before the operation,
2501    * so that the maximum guest memory is freed.
2502    *
2503    * @throws LibGuestFSException
2504    */
2505   public void drop_caches (int whattodrop)
2506     throws LibGuestFSException
2507   {
2508     if (g == 0)
2509       throw new LibGuestFSException ("drop_caches: handle is closed");
2510     _drop_caches (g, whattodrop);
2511   }
2512   private native void _drop_caches (long g, int whattodrop)
2513     throws LibGuestFSException;
2514
2515   /**
2516    * return kernel messages
2517    *
2518    * This returns the kernel messages ("dmesg" output) from
2519    * the guest kernel. This is sometimes useful for extended
2520    * debugging of problems.
2521    *
2522    * Another way to get the same information is to enable
2523    * verbose messages with "g.set_verbose" or by setting the
2524    * environment variable "LIBGUESTFS_DEBUG=1" before running
2525    * the program.
2526    *
2527    * @throws LibGuestFSException
2528    */
2529   public String dmesg ()
2530     throws LibGuestFSException
2531   {
2532     if (g == 0)
2533       throw new LibGuestFSException ("dmesg: handle is closed");
2534     return _dmesg (g);
2535   }
2536   private native String _dmesg (long g)
2537     throws LibGuestFSException;
2538
2539 }