guestfs_session_new ()

GuestfsSession *
guestfs_session_new (void);

Create a new libguestfs session.

guestfs_session_close ()

gboolean
guestfs_session_close (GuestfsSession *session,
                       GError **err);

Close a libguestfs session.

guestfs_session_acl_delete_def_file ()

gboolean
guestfs_session_acl_delete_def_file (GuestfsSession *session,
                                     const gchar *dir,
                                     GError **err);

delete the default POSIX ACL of a directory

This function deletes the default POSIX Access Control List (ACL) attached to directory dir .

Since: 1.19.63

guestfs_session_acl_get_file ()

gchar *
guestfs_session_acl_get_file (GuestfsSession *session,
                              const gchar *path,
                              const gchar *acltype,
                              GError **err);

get the POSIX ACL attached to a file

This function returns the POSIX Access Control List (ACL) attached to path . The ACL is returned in "long text form" (see acl(5)).

The acltype parameter may be:

access Return the ordinary (access) ACL for any file, directory or other filesystem object.

default Return the default ACL. Normally this only makes sense if path is a directory.

Since: 1.19.63

guestfs_session_acl_set_file ()

gboolean
guestfs_session_acl_set_file (GuestfsSession *session,
                              const gchar *path,
                              const gchar *acltype,
                              const gchar *acl,
                              GError **err);

set the POSIX ACL attached to a file

This function sets the POSIX Access Control List (ACL) attached to path .

The acltype parameter may be:

access Set the ordinary (access) ACL for any file, directory or other filesystem object.

default Set the default ACL. Normally this only makes sense if path is a directory.

The acl parameter is the new ACL in either "long text form" or "short text form" (see acl(5)). The new ACL completely replaces any previous ACL on the file. The ACL must contain the full Unix permissions (eg. "u::rwx,g::rx,o::rx").

If you are specifying individual users or groups, then the mask field is also required (eg. "m::rwx"), followed by the "u:*ID*:..." and/or "g:*ID*:..." field(s). A full ACL string might therefore look like this:

u::rwx,g::rwx,o::rwx,m::rwx,u:500:rwx,g:500:rwx

\ Unix permissions / \mask/ \ ACL /

You should use numeric UIDs and GIDs. To map usernames and groupnames to the correct numeric ID in the context of the guest, use the Augeas functions (see guestfs_session_aug_init()).

Since: 1.19.63

guestfs_session_add_cdrom ()

gboolean
guestfs_session_add_cdrom (GuestfsSession *session,
                           const gchar *filename,
                           GError **err);

add a CD-ROM disk image to examine

This function adds a virtual CD-ROM disk image to the guest.

The image is added as read-only drive, so this function is equivalent of guestfs_session_add_drive_ro().

Since: 0.3

guestfs_session_add_domain ()

gint32
guestfs_session_add_domain (GuestfsSession *session,
                            const gchar *dom,
                            GuestfsAddDomain *optargs,
                            GError **err);

add the disk(s) from a named libvirt domain

This function adds the disk(s) attached to the named libvirt domain dom . It works by connecting to libvirt, requesting the domain and domain XML from libvirt, parsing it for disks, and calling guestfs_session_add_drive_opts() on each one.

The number of disks added is returned. This operation is atomic: if an error is returned, then no disks are added.

This function does some minimal checks to make sure the libvirt domain is not running (unless readonly is true). In a future version we will try to acquire the libvirt lock on each disk.

Disks must be accessible locally. This often means that adding disks from a remote libvirt connection (see http://libvirt.org/remote.html ) will fail unless those disks are accessible via the same device path locally too.

The optional libvirturi parameter sets the libvirt URI (see http://libvirt.org/uri.html ). If this is not set then we connect to the default libvirt URI (or one set through an environment variable, see the libvirt documentation for full details).

The optional live flag controls whether this call will try to connect to a running virtual machine guestfsd process if it sees a suitable <channel> element in the libvirt XML definition. The default (if the flag is omitted) is never to try. See "ATTACHING TO RUNNING DAEMONS" in guestfs(3) for more information.

If the allowuuid flag is true (default is false) then a UUID *may* be passed instead of the domain name. The dom string is treated as a UUID first and looked up, and if that lookup fails then we treat dom as a name as usual.

The optional readonlydisk parameter controls what we do for disks which are marked <readonly/> in the libvirt XML. Possible values are:

readonlydisk = "error" If readonly is false:

The whole call is aborted with an error if any disk with the <readonly/> flag is found.

If readonly is true:

Disks with the <readonly/> flag are added read-only.

readonlydisk = "read" If readonly is false:

Disks with the <readonly/> flag are added read-only. Other disks are added read/write.

If readonly is true:

Disks with the <readonly/> flag are added read-only.

readonlydisk = "write" (default) If readonly is false:

Disks with the <readonly/> flag are added read/write.

If readonly is true:

Disks with the <readonly/> flag are added read-only.

readonlydisk = "ignore" If readonly is true or false:

Disks with the <readonly/> flag are skipped.

The other optional parameters are passed directly through to guestfs_session_add_drive_opts().

Since: 1.7.4

guestfs_session_add_drive ()

gboolean
guestfs_session_add_drive (GuestfsSession *session,
                           const gchar *filename,
                           GuestfsAddDrive *optargs,
                           GError **err);

add an image to examine or modify

This function adds a disk image called filename to the handle. filename may be a regular host file or a host device.

When this function is called before guestfs_session_launch() (the usual case) then the first time you call this function, the disk appears in the API as /dev/sda, the second time as /dev/sdb, and so on.

In libguestfs ≥ 1.20 you can also call this function after launch (with some restrictions). This is called "hotplugging". When hotplugging, you must specify a label so that the new disk gets a predictable name. For more information see "HOTPLUGGING" in guestfs(3).

You don't necessarily need to be root when using libguestfs. However you obviously do need sufficient permissions to access the filename for whatever operations you want to perform (ie. read access if you just want to read the image or write access if you want to modify the image).

This call checks that filename exists.

filename may be the special string "/dev/null". See "NULL DISKS" in guestfs(3).

The optional arguments are:

readonly If true then the image is treated as read-only. Writes are still allowed, but they are stored in a temporary snapshot overlay which is discarded at the end. The disk that you add is not modified.

format This forces the image format. If you omit this (or use guestfs_session_add_drive() or guestfs_session_add_drive_ro()) then the format is automatically detected. Possible formats include raw and qcow2 .

Automatic detection of the format opens you up to a potential security hole when dealing with untrusted raw-format images. See CVE-2010-3851 and RHBZ#642934 . Specifying the format closes this security hole.

iface This rarely-used option lets you emulate the behaviour of the deprecated guestfs_session_add_drive_with_if() call (q.v.)

name The name the drive had in the original guest, e.g. /dev/sdb. This is used as a hint to the guest inspection process if it is available.

label Give the disk a label. The label should be a unique, short string using *only* ASCII characters "[a-zA-Z]". As well as its usual name in the API (such as /dev/sda), the drive will also be named /dev/disk/guestfs/*label*.

See "DISK LABELS" in guestfs(3).

protocol The optional protocol argument can be used to select an alternate source protocol.

See also: "REMOTE STORAGE" in guestfs(3).

"protocol = "file"" filename is interpreted as a local file or device. This is the default if the optional protocol parameter is omitted.

"protocol = "ftp"|"ftps"|"http"|"https"|"tftp"" Connect to a remote FTP, HTTP or TFTP server. The server parameter must also be supplied - see below.

See also: "FTP, HTTP AND TFTP" in guestfs(3)

"protocol = "gluster"" Connect to the GlusterFS server. The server parameter must also be supplied - see below.

See also: "GLUSTER" in guestfs(3)

"protocol = "iscsi"" Connect to the iSCSI server. The server parameter must also be supplied - see below.

See also: "ISCSI" in guestfs(3).

"protocol = "nbd"" Connect to the Network Block Device server. The server parameter must also be supplied - see below.

See also: "NETWORK BLOCK DEVICE" in guestfs(3).

"protocol = "rbd"" Connect to the Ceph (librbd/RBD) server. The server parameter must also be supplied - see below. The username parameter may be supplied. See below. The secret parameter may be supplied. See below.

See also: "CEPH" in guestfs(3).

"protocol = "sheepdog"" Connect to the Sheepdog server. The server parameter may also be supplied - see below.

See also: "SHEEPDOG" in guestfs(3).

"protocol = "ssh"" Connect to the Secure Shell (ssh) server.

The server parameter must be supplied. The username parameter may be supplied. See below.

See also: "SSH" in guestfs(3).

server For protocols which require access to a remote server, this is a list of server(s).

Protocol Number of servers required

-------- --------------------------

file List must be empty or param not used at all

ftp|ftps|http|https|tftp Exactly one

gluster Exactly one

iscsi Exactly one

nbd Exactly one

rbd Zero or more

sheepdog Zero or more

ssh Exactly one

Each list element is a string specifying a server. The string must be in one of the following formats:

hostname

hostname:port

tcp:hostname

tcp:hostname:port

unix:/path/to/socket

If the port number is omitted, then the standard port number for the protocol is used (see /etc/services).

username For the ftp , ftps , http , https , iscsi , rbd , ssh and tftp protocols, this specifies the remote username.

If not given, then the local username is used for ssh , and no authentication is attempted for ceph. But note this sometimes may give unexpected results, for example if using the libvirt backend and if the libvirt backend is configured to start the qemu appliance as a special user such as "qemu.qemu". If in doubt, specify the remote username you want.

secret For the rbd protocol only, this specifies the 'secret' to use when connecting to the remote device. It must be base64 encoded.

If not given, then a secret matching the given username will be looked up in the default keychain locations, or if no username is given, then no authentication will be used.

cachemode Choose whether or not libguestfs will obey sync operations (safe but slow) or not (unsafe but fast). The possible values for this string are:

"cachemode = "writeback"" This is the default.

Write operations in the API do not return until a write(2) call has completed in the host [but note this does not imply that anything gets written to disk].

Sync operations in the API, including implicit syncs caused by filesystem journalling, will not return until an fdatasync(2) call has completed in the host, indicating that data has been committed to disk.

"cachemode = "unsafe"" In this mode, there are no guarantees. Libguestfs may cache anything and ignore sync requests. This is suitable only for scratch or temporary disks.

discard Enable or disable discard (a.k.a. trim or unmap) support on this drive. If enabled, operations such as guestfs_session_fstrim() will be able to discard / make thin / punch holes in the underlying host file or device.

Possible discard settings are:

"discard = "disable"" Disable discard support. This is the default.

"discard = "enable"" Enable discard support. Fail if discard is not possible.

"discard = "besteffort"" Enable discard support if possible, but don't fail if it is not supported.

Since not all backends and not all underlying systems support discard, this is a good choice if you want to use discard if possible, but don't mind if it doesn't work.

copyonread The boolean parameter copyonread enables copy-on-read support. This only affects disk formats which have backing files, and causes reads to be stored in the overlay layer, speeding up multiple reads of the same area of disk.

The default is false.

Since: 0.3

guestfs_session_add_drive_ro ()

gboolean
guestfs_session_add_drive_ro (GuestfsSession *session,
                              const gchar *filename,
                              GError **err);

add a drive in snapshot mode (read-only)

This function is the equivalent of calling guestfs_session_add_drive_opts() with the optional parameter GUESTFS_ADD_DRIVE_OPTS_READONLY set to 1, so the disk is added read-only, with the format being detected automatically.

Since: 1.0.38

guestfs_session_add_drive_ro_with_if ()

gboolean
guestfs_session_add_drive_ro_with_if (GuestfsSession *session,
                                      const gchar *filename,
                                      const gchar *iface,
                                      GError **err);

add a drive read-only specifying the QEMU block emulation to use

This is the same as guestfs_session_add_drive_ro() but it allows you to specify the QEMU interface emulation to use at run time.

Since: 1.0.84

guestfs_session_add_drive_scratch ()

gboolean
guestfs_session_add_drive_scratch (GuestfsSession *session,
                                   gint64 size,
                                   GuestfsAddDriveScratch *optargs,
                                   GError **err);

add a temporary scratch drive

This command adds a temporary scratch drive to the handle. The size parameter is the virtual size (in bytes). The scratch drive is blank initially (all reads return zeroes until you start writing to it). The drive is deleted when the handle is closed.

The optional arguments name and label are passed through to guestfs_session_add_drive().

Since: 1.23.10

guestfs_session_add_drive_with_if ()

gboolean
guestfs_session_add_drive_with_if (GuestfsSession *session,
                                   const gchar *filename,
                                   const gchar *iface,
                                   GError **err);

add a drive specifying the QEMU block emulation to use

This is the same as guestfs_session_add_drive() but it allows you to specify the QEMU interface emulation to use at run time.

Since: 1.0.84

guestfs_session_add_libvirt_dom ()

gint32
guestfs_session_add_libvirt_dom (GuestfsSession *session,
                                 void *dom,
                                 GuestfsAddLibvirtDom *optargs,
                                 GError **err);

add the disk(s) from a libvirt domain

This function adds the disk(s) attached to the libvirt domain dom . It works by requesting the domain XML from libvirt, parsing it for disks, and calling guestfs_session_add_drive_opts() on each one.

In the C API we declare "void *dom", but really it has type "virDomainPtr dom". This is so we don't need <libvirt.h>.

The number of disks added is returned. This operation is atomic: if an error is returned, then no disks are added.

This function does some minimal checks to make sure the libvirt domain is not running (unless readonly is true). In a future version we will try to acquire the libvirt lock on each disk.

Disks must be accessible locally. This often means that adding disks from a remote libvirt connection (see http://libvirt.org/remote.html ) will fail unless those disks are accessible via the same device path locally too.

The optional live flag controls whether this call will try to connect to a running virtual machine guestfsd process if it sees a suitable <channel> element in the libvirt XML definition. The default (if the flag is omitted) is never to try. See "ATTACHING TO RUNNING DAEMONS" in guestfs(3) for more information.

The optional readonlydisk parameter controls what we do for disks which are marked <readonly/> in the libvirt XML. See guestfs_session_add_domain() for possible values.

The other optional parameters are passed directly through to guestfs_session_add_drive_opts().

Since: 1.29.14

guestfs_session_aug_clear ()

gboolean
guestfs_session_aug_clear (GuestfsSession *session,
                           const gchar *augpath,
                           GError **err);

clear Augeas path

Set the value associated with path to NULL . This is the same as the augtool(1) clear command.

Since: 1.3.4

guestfs_session_aug_close ()

gboolean
guestfs_session_aug_close (GuestfsSession *session,
                           GError **err);

close the current Augeas handle

Close the current Augeas handle and free up any resources used by it. After calling this, you have to call guestfs_session_aug_init() again before you can use any other Augeas functions.

Since: 0.7

guestfs_session_aug_defnode ()

GuestfsIntBool *
guestfs_session_aug_defnode (GuestfsSession *session,
                             const gchar *name,
                             const gchar *expr,
                             const gchar *val,
                             GError **err);

define an Augeas node

Defines a variable name whose value is the result of evaluating expr .

If expr evaluates to an empty nodeset, a node is created, equivalent to calling guestfs_session_aug_set() expr , value . name will be the nodeset containing that single node.

On success this returns a pair containing the number of nodes in the nodeset, and a boolean flag if a node was created.

Since: 0.7

guestfs_session_aug_defvar ()

gint32
guestfs_session_aug_defvar (GuestfsSession *session,
                            const gchar *name,
                            const gchar *expr,
                            GError **err);

define an Augeas variable

Defines an Augeas variable name whose value is the result of evaluating expr . If expr is NULL, then name is undefined.

On success this returns the number of nodes in expr , or 0 if expr evaluates to something which is not a nodeset.

Since: 0.7

guestfs_session_aug_get ()

gchar *
guestfs_session_aug_get (GuestfsSession *session,
                         const gchar *augpath,
                         GError **err);

look up the value of an Augeas path

Look up the value associated with path . If path matches exactly one node, the value is returned.

Since: 0.7

guestfs_session_aug_init ()

gboolean
guestfs_session_aug_init (GuestfsSession *session,
                          const gchar *root,
                          gint32 flags,
                          GError **err);

create a new Augeas handle

Create a new Augeas handle for editing configuration files. If there was any previous Augeas handle associated with this guestfs session, then it is closed.

You must call this before using any other "guestfs_aug_*" commands.

root is the filesystem root. root must not be NULL, use / instead.

The flags are the same as the flags defined in <augeas.h>, the logical *or* of the following integers:

AUG_SAVE_BACKUP = 1 Keep the original file with a ".augsave" extension.

AUG_SAVE_NEWFILE = 2 Save changes into a file with extension ".augnew", and do not overwrite original. Overrides AUG_SAVE_BACKUP .

AUG_TYPE_CHECK = 4 Typecheck lenses.

This option is only useful when debugging Augeas lenses. Use of this option may require additional memory for the libguestfs appliance. You may need to set the LIBGUESTFS_MEMSIZE environment variable or call guestfs_session_set_memsize().

AUG_NO_STDINC = 8 Do not use standard load path for modules.

AUG_SAVE_NOOP = 16 Make save a no-op, just record what would have been changed.

AUG_NO_LOAD = 32 Do not load the tree in guestfs_session_aug_init().

To close the handle, you can call guestfs_session_aug_close().

To find out more about Augeas, see http://augeas.net/ .

Since: 0.7

guestfs_session_aug_insert ()

gboolean
guestfs_session_aug_insert (GuestfsSession *session,
                            const gchar *augpath,
                            const gchar *label,
                            gboolean before,
                            GError **err);

insert a sibling Augeas node

Create a new sibling label for path , inserting it into the tree before or after path (depending on the boolean flag before ).

path must match exactly one existing node in the tree, and label must be a label, ie. not contain /, "*" or end with a bracketed index "[N]".

Since: 0.7

guestfs_session_aug_label ()

gchar *
guestfs_session_aug_label (GuestfsSession *session,
                           const gchar *augpath,
                           GError **err);

return the label from an Augeas path expression

The label (name of the last element) of the Augeas path expression augpath is returned. augpath must match exactly one node, else this function returns an error.

Since: 1.23.14

guestfs_session_aug_load ()

gboolean
guestfs_session_aug_load (GuestfsSession *session,
                          GError **err);

load files into the tree

Load files into the tree.

See aug_load in the Augeas documentation for the full gory details.

Since: 0.7

guestfs_session_aug_ls ()

gchar **
guestfs_session_aug_ls (GuestfsSession *session,
                        const gchar *augpath,
                        GError **err);

list Augeas nodes under augpath

This is just a shortcut for listing guestfs_session_aug_match() "path/*" and sorting the resulting nodes into alphabetical order.

Since: 0.8

guestfs_session_aug_match ()

gchar **
guestfs_session_aug_match (GuestfsSession *session,
                           const gchar *augpath,
                           GError **err);

return Augeas nodes which match augpath

Returns a list of paths which match the path expression path . The returned paths are sufficiently qualified so that they match exactly one node in the current tree.

Since: 0.7

guestfs_session_aug_mv ()

gboolean
guestfs_session_aug_mv (GuestfsSession *session,
                        const gchar *src,
                        const gchar *dest,
                        GError **err);

move Augeas node

Move the node src to dest . src must match exactly one node. dest is overwritten if it exists.

Since: 0.7

guestfs_session_aug_rm ()

gint32
guestfs_session_aug_rm (GuestfsSession *session,
                        const gchar *augpath,
                        GError **err);

remove an Augeas path

Remove path and all of its children.

On success this returns the number of entries which were removed.

Since: 0.7

guestfs_session_aug_save ()

gboolean
guestfs_session_aug_save (GuestfsSession *session,
                          GError **err);

write all pending Augeas changes to disk

This writes all pending changes to disk.

The flags which were passed to guestfs_session_aug_init() affect exactly how files are saved.

Since: 0.7

guestfs_session_aug_set ()

gboolean
guestfs_session_aug_set (GuestfsSession *session,
                         const gchar *augpath,
                         const gchar *val,
                         GError **err);

set Augeas path to value

Set the value associated with path to val .

In the Augeas API, it is possible to clear a node by setting the value to NULL. Due to an oversight in the libguestfs API you cannot do that with this call. Instead you must use the guestfs_session_aug_clear() call.

Since: 0.7

guestfs_session_aug_setm ()

gint32
guestfs_session_aug_setm (GuestfsSession *session,
                          const gchar *base,
                          const gchar *sub,
                          const gchar *val,
                          GError **err);

set multiple Augeas nodes

Change multiple Augeas nodes in a single operation. base is an expression matching multiple nodes. sub is a path expression relative to base . All nodes matching base are found, and then for each node, sub is changed to val . sub may also be NULL in which case the base nodes are modified.

This returns the number of nodes modified.

Since: 1.23.14

guestfs_session_available ()

gboolean
guestfs_session_available (GuestfsSession *session,
                           gchar *const *groups,
                           GError **err);

test availability of some parts of the API

This command is used to check the availability of some groups of functionality in the appliance, which not all builds of the libguestfs appliance will be able to provide.

The libguestfs groups, and the functions that those groups correspond to, are listed in "AVAILABILITY" in guestfs(3). You can also fetch this list at runtime by calling guestfs_session_available_all_groups().

The argument groups is a list of group names, eg: "["inotify", "augeas"]" would check for the availability of the Linux inotify functions and Augeas (configuration file editing) functions.

The command returns no error if *all* requested groups are available.

It fails with an error if one or more of the requested groups is unavailable in the appliance.

If an unknown group name is included in the list of groups then an error is always returned.

*Notes:*

The reason is because we don't know what groups are supported by the appliance/daemon until it is running and can be queried.

See also guestfs_session_filesystem_available().

Since: 1.0.80

guestfs_session_available_all_groups ()

gchar **
guestfs_session_available_all_groups (GuestfsSession *session,
                                      GError **err);

return a list of all optional groups

This command returns a list of all optional groups that this daemon knows about. Note this returns both supported and unsupported groups. To find out which ones the daemon can actually support you have to call guestfs_session_available() / guestfs_session_feature_available() on each member of the returned list.

See also guestfs_session_available(), guestfs_session_feature_available() and "AVAILABILITY" in guestfs(3).

Since: 1.3.15

guestfs_session_base64_in ()

gboolean
guestfs_session_base64_in (GuestfsSession *session,
                           const gchar *base64file,
                           const gchar *filename,
                           GCancellable *cancellable,
                           GError **err);

upload base64-encoded data to file

This command uploads base64-encoded data from base64file to filename.

Since: 1.3.5

guestfs_session_base64_out ()

gboolean
guestfs_session_base64_out (GuestfsSession *session,
                            const gchar *filename,
                            const gchar *base64file,
                            GCancellable *cancellable,
                            GError **err);

download file and encode as base64

This command downloads the contents of filename, writing it out to local file base64file encoded as base64.

Since: 1.3.5

guestfs_session_blkdiscard ()

gboolean
guestfs_session_blkdiscard (GuestfsSession *session,
                            const gchar *device,
                            GError **err);

discard all blocks on a device

This discards all blocks on the block device device , giving the free space back to the host.

This operation requires support in libguestfs, the host filesystem, qemu and the host kernel. If this support isn't present it may give an error or even appear to run but do nothing. You must also set the discard attribute on the underlying drive (see guestfs_session_add_drive_opts()).

Since: 1.25.44

guestfs_session_blkdiscardzeroes ()

gint8
guestfs_session_blkdiscardzeroes (GuestfsSession *session,
                                  const gchar *device,
                                  GError **err);

return true if discarded blocks are read as zeroes

This call returns true if blocks on device that have been discarded by a call to guestfs_session_blkdiscard() are returned as blocks of zero bytes when read the next time.

If it returns false, then it may be that discarded blocks are read as stale or random data.

Since: 1.25.44

guestfs_session_blkid ()

GHashTable *
guestfs_session_blkid (GuestfsSession *session,
                       const gchar *device,
                       GError **err);

print block device attributes

This command returns block device attributes for device . The following fields are usually present in the returned hash. Other fields may also be present.

UUID The uuid of this device.

LABEL The label of this device.

VERSION The version of blkid command.

TYPE The filesystem type or RAID of this device.

USAGE The usage of this device, for example filesystem or raid .

Since: 1.15.9

guestfs_session_blockdev_flushbufs ()

gboolean
guestfs_session_blockdev_flushbufs (GuestfsSession *session,
                                    const gchar *device,
                                    GError **err);

flush device buffers

This tells the kernel to flush internal buffers associated with device .

This uses the blockdev(8) command.

Since: 1.9.3

guestfs_session_blockdev_getbsz ()

gint32
guestfs_session_blockdev_getbsz (GuestfsSession *session,
                                 const gchar *device,
                                 GError **err);

get blocksize of block device

This returns the block size of a device.

Note: this is different from both *size in blocks* and *filesystem block size*. Also this setting is not really used by anything. You should probably not use it for anything. Filesystems have their own idea about what block size to choose.

This uses the blockdev(8) command.

Since: 1.9.3

guestfs_session_blockdev_getro ()

gint8
guestfs_session_blockdev_getro (GuestfsSession *session,
                                const gchar *device,
                                GError **err);

is block device set to read-only

Returns a boolean indicating if the block device is read-only (true if read-only, false if not).

This uses the blockdev(8) command.

Since: 1.9.3

guestfs_session_blockdev_getsize64 ()

gint64
guestfs_session_blockdev_getsize64 (GuestfsSession *session,
                                    const gchar *device,
                                    GError **err);

get total size of device in bytes

This returns the size of the device in bytes.

See also guestfs_session_blockdev_getsz().

This uses the blockdev(8) command.

Since: 1.9.3

guestfs_session_blockdev_getss ()

gint32
guestfs_session_blockdev_getss (GuestfsSession *session,
                                const gchar *device,
                                GError **err);

get sectorsize of block device

This returns the size of sectors on a block device. Usually 512, but can be larger for modern devices.

(Note, this is not the size in sectors, use guestfs_session_blockdev_getsz() for that).

This uses the blockdev(8) command.

Since: 1.9.3

guestfs_session_blockdev_getsz ()

gint64
guestfs_session_blockdev_getsz (GuestfsSession *session,
                                const gchar *device,
                                GError **err);

get total size of device in 512-byte sectors

This returns the size of the device in units of 512-byte sectors (even if the sectorsize isn't 512 bytes ... weird).

See also guestfs_session_blockdev_getss() for the real sector size of the device, and guestfs_session_blockdev_getsize64() for the more useful *size in bytes*.

This uses the blockdev(8) command.

Since: 1.9.3

guestfs_session_blockdev_rereadpt ()

gboolean
guestfs_session_blockdev_rereadpt (GuestfsSession *session,
                                   const gchar *device,
                                   GError **err);

reread partition table

Reread the partition table on device .

This uses the blockdev(8) command.

Since: 1.9.3

guestfs_session_blockdev_setbsz ()

gboolean
guestfs_session_blockdev_setbsz (GuestfsSession *session,
                                 const gchar *device,
                                 gint32 blocksize,
                                 GError **err);

set blocksize of block device

This call does nothing and has never done anything because of a bug in blockdev. Do not use it.

If you need to set the filesystem block size, use the blocksize option of guestfs_session_mkfs().

Since: 1.9.3

guestfs_session_blockdev_setra ()

gboolean
guestfs_session_blockdev_setra (GuestfsSession *session,
                                const gchar *device,
                                gint32 sectors,
                                GError **err);

set readahead

Set readahead (in 512-byte sectors) for the device.

This uses the blockdev(8) command.

Since: 1.29.10

guestfs_session_blockdev_setro ()

gboolean
guestfs_session_blockdev_setro (GuestfsSession *session,
                                const gchar *device,
                                GError **err);

set block device to read-only

Sets the block device named device to read-only.

This uses the blockdev(8) command.

Since: 1.9.3

guestfs_session_blockdev_setrw ()

gboolean
guestfs_session_blockdev_setrw (GuestfsSession *session,
                                const gchar *device,
                                GError **err);

set block device to read-write

Sets the block device named device to read-write.

This uses the blockdev(8) command.

Since: 1.9.3

guestfs_session_btrfs_balance_cancel ()

gboolean
guestfs_session_btrfs_balance_cancel (GuestfsSession *session,
                                      const gchar *path,
                                      GError **err);

cancel a running or paused balance

Cancel a running balance on a btrfs filesystem.

Since: 1.29.22

guestfs_session_btrfs_balance_pause ()

gboolean
guestfs_session_btrfs_balance_pause (GuestfsSession *session,
                                     const gchar *path,
                                     GError **err);

pause a running balance

Pause a running balance on a btrfs filesystem.

Since: 1.29.22

guestfs_session_btrfs_balance_resume ()

gboolean
guestfs_session_btrfs_balance_resume (GuestfsSession *session,
                                      const gchar *path,
                                      GError **err);

resume a paused balance

Resume a paused balance on a btrfs filesystem.

Since: 1.29.22

guestfs_session_btrfs_balance_status ()

GuestfsBTRFSBalance *
guestfs_session_btrfs_balance_status (GuestfsSession *session,
                                      const gchar *path,
                                      GError **err);

show the status of a running or paused balance

Show the status of a running or paused balance on a btrfs filesystem.

Since: 1.29.26

guestfs_session_btrfs_device_add ()

gboolean
guestfs_session_btrfs_device_add (GuestfsSession *session,
                                  gchar *const *devices,
                                  const gchar *fs,
                                  GError **err);

add devices to a btrfs filesystem

Add the list of device(s) in devices to the btrfs filesystem mounted at fs . If devices is an empty list, this does nothing.

Since: 1.17.35

guestfs_session_btrfs_device_delete ()

gboolean
guestfs_session_btrfs_device_delete (GuestfsSession *session,
                                     gchar *const *devices,
                                     const gchar *fs,
                                     GError **err);

remove devices from a btrfs filesystem

Remove the devices from the btrfs filesystem mounted at fs . If devices is an empty list, this does nothing.

Since: 1.17.35

guestfs_session_btrfs_filesystem_balance ()

gboolean
guestfs_session_btrfs_filesystem_balance
                               (GuestfsSession *session,
                                const gchar *fs,
                                GError **err);

balance a btrfs filesystem

Balance the chunks in the btrfs filesystem mounted at fs across the underlying devices.

Since: 1.17.35

guestfs_session_btrfs_filesystem_defragment ()

gboolean
guestfs_session_btrfs_filesystem_defragment
                               (GuestfsSession *session,
                                const gchar *path,
                                GuestfsBTRFSFilesystemDefragment *optargs,
                                GError **err);

defragment a file or directory

Defragment a file or directory on a btrfs filesystem. compress is one of zlib or lzo.

Since: 1.29.22

guestfs_session_btrfs_filesystem_resize ()

gboolean
guestfs_session_btrfs_filesystem_resize
                               (GuestfsSession *session,
                                const gchar *mountpoint,
                                GuestfsBTRFSFilesystemResize *optargs,
                                GError **err);

resize a btrfs filesystem

This command resizes a btrfs filesystem.

Note that unlike other resize calls, the filesystem has to be mounted and the parameter is the mountpoint not the device (this is a requirement of btrfs itself).

The optional parameters are:

size The new size (in bytes) of the filesystem. If omitted, the filesystem is resized to the maximum size.

See also btrfs(8).

Since: 1.11.17

guestfs_session_btrfs_filesystem_sync ()

gboolean
guestfs_session_btrfs_filesystem_sync (GuestfsSession *session,
                                       const gchar *fs,
                                       GError **err);

sync a btrfs filesystem

Force sync on the btrfs filesystem mounted at fs .