///
///
///
///
/**
* Type Definitions for Gjs (https://gjs.guide/)
*
* These type definitions are automatically generated, do not edit them by hand.
* If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
*
* The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
*/
declare module 'gi://BlockDev?version=3.0' {
// Module dependencies
import type Gio from 'gi://Gio?version=2.0';
import type GObject from 'gi://GObject?version=2.0';
import type GLib from 'gi://GLib?version=2.0';
import type GModule from 'gi://GModule?version=2.0';
export namespace BlockDev {
/**
* BlockDev-3.0
*/
class BtrfsError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static DEVICE: number;
static PARSE: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace BtrfsTech {
export const $gtype: GObject.GType;
}
enum BtrfsTech {
FS,
MULTI_DEV,
SUBVOL,
SNAPSHOT,
}
class CryptoError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static DEVICE: number;
static STATE: number;
static INVALID_SPEC: number;
static FORMAT_FAILED: number;
static RESIZE_FAILED: number;
static RESIZE_PERM: number;
static ADD_KEY: number;
static REMOVE_KEY: number;
static NO_KEY: number;
static KEY_SLOT: number;
static NSS_INIT_FAILED: number;
static CERT_DECODE: number;
static ESCROW_FAILED: number;
static INVALID_PARAMS: number;
static KEYRING: number;
static KEYFILE_FAILED: number;
static INVALID_CONTEXT: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace CryptoKeyslotContextType {
export const $gtype: GObject.GType;
}
enum CryptoKeyslotContextType {
NONE,
PASSPHRASE,
KEYFILE,
KEYRING,
VOLUME_KEY,
}
export namespace CryptoLUKSHWEncryptionType {
export const $gtype: GObject.GType;
}
enum CryptoLUKSHWEncryptionType {
/**
* used for unknown/unsupported hardware encryption or when
* error was detected when getting the information
*/
UNKNOWN,
/**
* hardware encryption is not configured on this device
*/
SW_ONLY,
/**
* only OPAL hardware encryption is configured on this device
*/
OPAL_HW_ONLY,
/**
* both OPAL hardware encryption and software encryption
* (using LUKS/dm-crypt) is configured on this device
*/
OPAL_HW_AND_SW,
}
export namespace CryptoLUKSVersion {
export const $gtype: GObject.GType;
}
enum CryptoLUKSVersion {
LUKS1,
LUKS2,
}
export namespace CryptoTech {
export const $gtype: GObject.GType;
}
enum CryptoTech {
LUKS,
TRUECRYPT,
ESCROW,
INTEGRITY,
BITLK,
KEYRING,
FVAULT2,
SED_OPAL,
}
class DMError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static SYS: number;
static NOT_ROOT: number;
static TASK: number;
static RAID_FAIL: number;
static RAID_NO_DEVS: number;
static RAID_NO_EXIST: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace DMTech {
export const $gtype: GObject.GType;
}
enum DMTech {
DM_TECH_MAP,
}
class FSError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static INVAL: number;
static PARSE: number;
static FAIL: number;
static NOFS: number;
static PIPE: number;
static UNMOUNT_FAIL: number;
static NOT_SUPPORTED: number;
static NOT_MOUNTED: number;
static AUTH: number;
static LABEL_INVALID: number;
static UUID_INVALID: number;
static UNKNOWN_FS: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace FSTech {
export const $gtype: GObject.GType;
}
enum FSTech {
GENERIC,
MOUNT,
EXT2,
EXT3,
EXT4,
XFS,
VFAT,
NTFS,
F2FS,
NILFS2,
EXFAT,
BTRFS,
UDF,
}
class InitError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static FAILED: number;
static PLUGINS_FAILED: number;
static NOT_IMPLEMENTED: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace LVMCacheMode {
export const $gtype: GObject.GType;
}
enum LVMCacheMode {
UNKNOWN,
WRITETHROUGH,
WRITEBACK,
}
class LVMError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static FAIL: number;
static PARSE: number;
static NOEXIST: number;
static DM_ERROR: number;
static NOT_ROOT: number;
static CACHE_INVAL: number;
static CACHE_NOCACHE: number;
static NOT_SUPPORTED: number;
static VDO_POLICY_INVAL: number;
static DEVICES_DISABLED: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace LVMTech {
export const $gtype: GObject.GType;
}
enum LVMTech {
BASIC,
BASIC_SNAP,
THIN,
CACHE,
CALCS,
THIN_CALCS,
CACHE_CALCS,
GLOB_CONF,
VDO,
WRITECACHE,
DEVICES,
SHARED,
CONFIG,
}
export namespace LVMVDOCompressionState {
export const $gtype: GObject.GType;
}
enum LVMVDOCompressionState {
UNKNOWN,
ONLINE,
OFFLINE,
}
export namespace LVMVDOIndexState {
export const $gtype: GObject.GType;
}
enum LVMVDOIndexState {
UNKNOWN,
ERROR,
CLOSED,
OPENING,
CLOSING,
OFFLINE,
ONLINE,
}
export namespace LVMVDOOperatingMode {
export const $gtype: GObject.GType;
}
enum LVMVDOOperatingMode {
UNKNOWN,
RECOVERING,
READ_ONLY,
NORMAL,
}
export namespace LVMVDOWritePolicy {
export const $gtype: GObject.GType;
}
enum LVMVDOWritePolicy {
UNKNOWN,
AUTO,
SYNC,
ASYNC,
}
class LoopError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static FAIL: number;
static DEVICE: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace LoopTech {
export const $gtype: GObject.GType;
}
enum LoopTech {
LOOP_TECH_LOOP,
}
class MDError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static FAIL: number;
static PARSE: number;
static BAD_FORMAT: number;
static NO_MATCH: number;
static INVAL: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace MDTech {
export const $gtype: GObject.GType;
}
enum MDTech {
MD_TECH_MDRAID,
}
class MpathError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static INVAL: number;
static FLUSH: number;
static NOT_ROOT: number;
static DM_ERROR: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace MpathTech {
export const $gtype: GObject.GType;
}
enum MpathTech {
BASE,
FRIENDLY_NAMES,
}
class NVDIMMError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static NAMESPACE_FAIL: number;
static NAMESPACE_PARSE: number;
static NAMESPACE_NOEXIST: number;
static NAMESPACE_MODE_INVAL: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace NVDIMMNamespaceMode {
export const $gtype: GObject.GType;
}
enum NVDIMMNamespaceMode {
RAW,
SECTOR,
MEMORY,
DAX,
FSDAX,
DEVDAX,
UNKNOWN,
}
export namespace NVDIMMTech {
export const $gtype: GObject.GType;
}
enum NVDIMMTech {
NVDIMM_TECH_NAMESPACE,
}
export namespace NVMEControllerType {
export const $gtype: GObject.GType;
}
enum NVMEControllerType {
UNKNOWN,
IO,
DISCOVERY,
ADMIN,
}
class NVMEError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static FAILED: number;
static BUSY: number;
static INVALID_ARGUMENT: number;
static WOULD_FORMAT_ALL_NS: number;
static SC_GENERIC: number;
static SC_CMD_SPECIFIC: number;
static SC_MEDIA: number;
static SC_PATH: number;
static SC_VENDOR_SPECIFIC: number;
static NO_MATCH: number;
static CONNECT: number;
static CONNECT_ALREADY: number;
static CONNECT_INVALID: number;
static CONNECT_ADDRINUSE: number;
static CONNECT_NODEV: number;
static CONNECT_OPNOTSUPP: number;
static CONNECT_REFUSED: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace NVMEFormatSecureErase {
export const $gtype: GObject.GType;
}
enum NVMEFormatSecureErase {
NONE,
USER_DATA,
CRYPTO,
}
export namespace NVMELBAFormatRelativePerformance {
export const $gtype: GObject.GType;
}
enum NVMELBAFormatRelativePerformance {
UNKNOWN,
BEST,
BETTER,
GOOD,
DEGRADED,
}
export namespace NVMESanitizeAction {
export const $gtype: GObject.GType;
}
enum NVMESanitizeAction {
EXIT_FAILURE,
BLOCK_ERASE,
OVERWRITE,
CRYPTO_ERASE,
}
export namespace NVMESanitizeStatus {
export const $gtype: GObject.GType;
}
enum NVMESanitizeStatus {
NEVER_SANITIZED,
IN_PROGESS,
SUCCESS,
SUCCESS_NO_DEALLOC,
FAILED,
}
export namespace NVMESelfTestAction {
export const $gtype: GObject.GType;
}
enum NVMESelfTestAction {
NOT_RUNNING,
SHORT,
EXTENDED,
VENDOR_SPECIFIC,
ABORT,
}
export namespace NVMESelfTestResult {
export const $gtype: GObject.GType;
}
enum NVMESelfTestResult {
NO_ERROR,
ABORTED,
CTRL_RESET,
NS_REMOVED,
ABORTED_FORMAT,
FATAL_ERROR,
UNKNOWN_SEG_FAIL,
KNOWN_SEG_FAIL,
ABORTED_UNKNOWN,
ABORTED_SANITIZE,
}
export namespace NVMETech {
export const $gtype: GObject.GType;
}
enum NVMETech {
NVME,
FABRICS,
}
export namespace NVMETransportType {
export const $gtype: GObject.GType;
}
enum NVMETransportType {
UNSPECIFIED,
RDMA,
FC,
TCP,
LOOP,
}
export namespace PartAlign {
export const $gtype: GObject.GType;
}
enum PartAlign {
NONE,
MINIMAL,
OPTIMAL,
}
class PartError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static FAIL: number;
static INVAL: number;
static EXISTS: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace PartTableType {
export const $gtype: GObject.GType;
}
enum PartTableType {
MSDOS,
GPT,
UNDEF,
}
export namespace PartTech {
export const $gtype: GObject.GType;
}
enum PartTech {
MBR,
GPT,
}
export namespace PartType {
export const $gtype: GObject.GType;
}
enum PartType {
NORMAL,
LOGICAL,
EXTENDED,
FREESPACE,
METADATA,
PROTECTED,
}
export namespace PartTypeReq {
export const $gtype: GObject.GType;
}
enum PartTypeReq {
NORMAL,
LOGICAL,
EXTENDED,
NEXT,
}
export namespace Plugin {
export const $gtype: GObject.GType;
}
enum Plugin {
LVM,
BTRFS,
SWAP,
LOOP,
CRYPTO,
MPATH,
DM,
MDRAID,
S390,
PART,
FS,
NVDIMM,
NVME,
SMART,
UNDEF,
}
export namespace SmartATAAttributeFlag {
export const $gtype: GObject.GType;
}
enum SmartATAAttributeFlag {
PREFAILURE,
ONLINE,
PERFORMANCE,
ERROR_RATE,
EVENT_COUNT,
SELF_PRESERVING,
OTHER,
}
export namespace SmartATAAttributeUnit {
export const $gtype: GObject.GType;
}
enum SmartATAAttributeUnit {
UNKNOWN,
NONE,
MSECONDS,
SECTORS,
MKELVIN,
SMALL_PERCENT,
PERCENT,
MB,
}
export namespace SmartATAOfflineDataCollectionCapabilities {
export const $gtype: GObject.GType;
}
enum SmartATAOfflineDataCollectionCapabilities {
NOT_SUPPORTED,
EXEC_OFFLINE_IMMEDIATE,
OFFLINE_ABORT,
OFFLINE_SURFACE_SCAN,
SELF_TEST,
CONVEYANCE_SELF_TEST,
SELECTIVE_SELF_TEST,
}
export namespace SmartATAOfflineDataCollectionStatus {
export const $gtype: GObject.GType;
}
enum SmartATAOfflineDataCollectionStatus {
NEVER_STARTED,
NO_ERROR,
IN_PROGRESS,
SUSPENDED_INTR,
ABORTED_INTR,
ABORTED_ERROR,
VENDOR_SPECIFIC,
RESERVED,
}
export namespace SmartATASelfTestStatus {
export const $gtype: GObject.GType;
}
enum SmartATASelfTestStatus {
COMPLETED_NO_ERROR,
ABORTED_HOST,
INTR_HOST_RESET,
ERROR_FATAL,
ERROR_UNKNOWN,
ERROR_ELECTRICAL,
ERROR_SERVO,
ERROR_READ,
ERROR_HANDLING,
IN_PROGRESS,
}
class SmartError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static FAILED: number;
static INVALID_ARGUMENT: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace SmartSCSIBackgroundScanStatus {
export const $gtype: GObject.GType;
}
enum SmartSCSIBackgroundScanStatus {
NO_SCANS_ACTIVE,
SCAN_ACTIVE,
PRESCAN_ACTIVE,
HALTED_ERROR_FATAL,
HALTED_PATTERN_VENDOR_SPECIFIC,
HALTED_ERROR_PLIST,
HALTED_VENDOR_SPECIFIC,
HALTED_TEMPERATURE,
BMS_TIMER,
}
export namespace SmartSCSIInformationalException {
export const $gtype: GObject.GType;
}
enum SmartSCSIInformationalException {
NONE,
ABORTED_COMMAND,
TEMPERATURE_EXCEEDED,
ENCLOSURE_DEGRADED,
BACKGROUND_SELFTEST_FAILED,
BACKGROUND_PRESCAN_MEDIUM_ERROR,
BACKGROUND_SCAN_MEDIUM_ERROR,
NV_CACHE_VOLATILE,
NV_CACHE_DEGRADED_POWER,
POWER_LOSS_EXPECTED,
STATISTICS_NOTIFICATION,
HIGH_CRITICAL_TEMP,
LOW_CRITICAL_TEMP,
HIGH_OPERATING_TEMP,
LOW_OPERATING_TEMP,
HIGH_CRITICAL_HUMIDITY,
LOW_CRITICAL_HUMIDITY,
HIGH_OPERATING_HUMIDITY,
LOW_OPERATING_HUMIDITY,
MICROCODE_SECURITY_RISK,
MICROCODE_SIGNATURE_VALIDATION_FAILURE,
PHYSICAL_ELEMENT_STATUS_CHANGE,
FAILURE_PREDICTION_THRESH,
MEDIA_FAILURE_PREDICTION_THRESH,
LOGICAL_UNIT_FAILURE_PREDICTION_THRESH,
SPARE_EXHAUSTION_PREDICTION_THRESH,
HARDWARE_IMPENDING_FAILURE,
CONTROLLER_IMPENDING_FAILURE,
DATA_CHANNEL_IMPENDING_FAILURE,
SERVO_IMPENDING_FAILURE,
SPINDLE_IMPENDING_FAILURE,
FIRMWARE_IMPENDING_FAILURE,
MEDIA_ENDURANCE_LIMIT,
UNSPECIFIED,
}
export namespace SmartSelfTestOp {
export const $gtype: GObject.GType;
}
enum SmartSelfTestOp {
ABORT,
OFFLINE,
SHORT,
LONG,
CONVEYANCE,
}
export namespace SmartTech {
export const $gtype: GObject.GType;
}
enum SmartTech {
ATA,
SCSI,
}
class SwapError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static TECH_UNAVAIL: number;
static UNKNOWN_STATE: number;
static ACTIVATE: number;
static ACTIVATE_OLD: number;
static ACTIVATE_SUSPEND: number;
static ACTIVATE_UNKNOWN: number;
static ACTIVATE_PAGESIZE: number;
static LABEL_INVALID: number;
static UUID_INVALID: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace SwapTech {
export const $gtype: GObject.GType;
}
enum SwapTech {
SWAP_TECH_SWAP,
}
class UtilsDBusError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static FAIL: number;
static NOEXIST: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
class UtilsDevUtilsError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static UTILS_DEV_UTILS_ERROR_FAILED: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
class UtilsExecError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static FAILED: number;
static NOOUT: number;
static INVAL_VER: number;
static UTIL_UNAVAILABLE: number;
static UTIL_UNKNOWN_VER: number;
static UTIL_LOW_VER: number;
static UTIL_CHECK_ERROR: number;
static UTIL_FEATURE_CHECK_ERROR: number;
static UTIL_FEATURE_UNAVAILABLE: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
class UtilsModuleError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
static KMOD_INIT_FAIL: number;
static FAIL: number;
static NOEXIST: number;
static MODULE_CHECK_ERROR: number;
static INVALID_PLATFORM: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
}
export namespace UtilsProgStatus {
export const $gtype: GObject.GType;
}
enum UtilsProgStatus {
STARTED,
PROGRESS,
FINISHED,
}
const BTRFS_MAIN_VOLUME_ID: number;
const BTRFS_MIN_MEMBER_SIZE: number;
const MD_CHUNK_SIZE: number;
const MD_SUPERBLOCK_SIZE: number;
const UTILS_LOG_ALERT: number;
const UTILS_LOG_CRIT: number;
const UTILS_LOG_DEBUG: number;
const UTILS_LOG_EMERG: number;
const UTILS_LOG_ERR: number;
const UTILS_LOG_INFO: number;
const UTILS_LOG_NOTICE: number;
const UTILS_LOG_WARNING: number;
function btrfs_add_device(mountpoint: string, device: string, extra?: ExtraArg[] | null): boolean;
function btrfs_change_label(mountpoint: string, label: string): boolean;
function btrfs_check(device: string, extra?: ExtraArg[] | null): boolean;
function btrfs_create_snapshot(source: string, dest: string, ro: boolean, extra?: ExtraArg[] | null): boolean;
function btrfs_create_subvolume(mountpoint: string, name: string, extra?: ExtraArg[] | null): boolean;
function btrfs_create_volume(
devices: string[],
label?: string | null,
data_level?: string | null,
md_level?: string | null,
extra?: ExtraArg[] | null,
): boolean;
function btrfs_delete_subvolume(mountpoint: string, name: string, extra?: ExtraArg[] | null): boolean;
function btrfs_error_quark(): GLib.Quark;
function btrfs_filesystem_info(device: string): BtrfsFilesystemInfo;
function btrfs_get_default_subvolume_id(mountpoint: string): number;
function btrfs_is_tech_avail(tech: BtrfsTech | null, mode: number): boolean;
function btrfs_list_devices(device: string): BtrfsDeviceInfo[];
function btrfs_list_subvolumes(mountpoint: string, snapshots_only: boolean): BtrfsSubvolumeInfo[];
function btrfs_mkfs(
devices: string[],
label?: string | null,
data_level?: string | null,
md_level?: string | null,
extra?: ExtraArg[] | null,
): boolean;
function btrfs_remove_device(mountpoint: string, device: string, extra?: ExtraArg[] | null): boolean;
function btrfs_repair(device: string, extra?: ExtraArg[] | null): boolean;
function btrfs_resize(mountpoint: string, size: number, extra?: ExtraArg[] | null): boolean;
function btrfs_set_default_subvolume(mountpoint: string, subvol_id: number, extra?: ExtraArg[] | null): boolean;
function crypto_bitlk_close(bitlk_device: string): boolean;
/**
* Returns (transfer full): information about the `device` or %NULL in case of error
*
* Tech category: %BD_CRYPTO_TECH_BITLK-%BD_CRYPTO_TECH_MODE_QUERY
* @param device a device to get information about
*/
function crypto_bitlk_info(device: string): CryptoBITLKInfo;
/**
* Supported `context` types for this function: passphrase, key file
* @param device the device to open
* @param name name for the BITLK device
* @param context key slot context (passphrase/keyfile/token...) for this BITLK device
* @param read_only whether to open as read-only or not (meaning read-write)
* @returns whether the @device was successfully opened or not Tech category: %BD_CRYPTO_TECH_BITLK-%BD_CRYPTO_TECH_MODE_OPEN_CLOSE
*/
function crypto_bitlk_open(
device: string,
name: string,
context: CryptoKeyslotContext,
read_only: boolean,
): boolean;
function crypto_device_is_luks(device: string): boolean;
/**
* Determines whether a block device seems to be encrypted.
*
* TCRYPT volumes are not easily identifiable, because they have no
* cleartext header, but are completely encrypted. This function is
* used to determine whether a block device is a candidate for being
* TCRYPT encrypted.
*
* To achieve this, we calculate the chi square value of the first
* 512 Bytes and treat devices with a chi square value between 136
* and 426 as candidates for being encrypted.
* For the reasoning, see: https://tails.boum.org/blueprint/veracrypt/
* @param device the queried device
* @returns %TRUE if the given @device seems to be encrypted or %FALSE if not or failed to determine (the @error) is populated with the error in such cases) Tech category: %BD_CRYPTO_TECH_TRUECRYPT-%BD_CRYPTO_TECH_MODE_QUERY
*/
function crypto_device_seems_encrypted(device: string): boolean;
function crypto_error_quark(): GLib.Quark;
function crypto_escrow_device(
device: string,
passphrase: string,
cert_data: number[],
directory: string,
backup_passphrase?: string | null,
): boolean;
function crypto_fvault2_close(fvault2_device: string): boolean;
/**
* Supported `context` types for this function: passphrase, key file
* @param device the device to open
* @param name name for the FVAULT2 device
* @param context key slot context (passphrase/keyfile/token...) for this FVAULT2 volume
* @param read_only whether to open as read-only or not (meaning read-write)
* @returns whether the @device was successfully opened or not Tech category: %BD_CRYPTO_TECH_FVAULT2-%BD_CRYPTO_TECH_MODE_OPEN_CLOSE
*/
function crypto_fvault2_open(
device: string,
name: string,
context: CryptoKeyslotContext,
read_only: boolean,
): boolean;
function crypto_generate_backup_passphrase(): string;
function crypto_integrity_close(integrity_device: string): boolean;
/**
* Formats the given `device` as integrity according to the other parameters given.
*
* Supported `context` types for this function: volume key
* @param device a device to format as integrity
* @param algorithm integrity algorithm specification (e.g. "crc32c" or "sha256")
* @param wipe whether to wipe the device after format; a device that is not initially wiped will contain invalid checksums
* @param context key slot context (passphrase/keyfile/token...) for this device
* @param extra extra arguments for integrity format creation
* @returns whether the given @device was successfully formatted as integrity or not (the @error) contains the error in such cases) Tech category: %BD_CRYPTO_TECH_INTEGRITY-%BD_CRYPTO_TECH_MODE_CREATE
*/
function crypto_integrity_format(
device: string,
algorithm: string,
wipe: boolean,
context?: CryptoKeyslotContext | null,
extra?: CryptoIntegrityExtra | null,
): boolean;
function crypto_integrity_info(device: string): CryptoIntegrityInfo;
/**
* Supported `context` types for this function: volume key
* @param device integrity device to open
* @param name name for the opened @device
* @param algorithm integrity algorithm specification (e.g. "crc32c" or "sha256")
* @param context key slot context (passphrase/keyfile/token...) for this device
* @param flags flags for the integrity device activation
* @param extra extra arguments for integrity open
* @returns whether the @device was successfully opened or not Tech category: %BD_CRYPTO_TECH_INTEGRITY-%BD_CRYPTO_TECH_MODE_OPEN_CLOSE
*/
function crypto_integrity_open(
device: string,
name: string,
algorithm: string,
context: CryptoKeyslotContext | null,
flags: CryptoIntegrityOpenFlags | null,
extra?: CryptoIntegrityExtra | null,
): boolean;
function crypto_is_tech_avail(tech: CryptoTech | null, mode: number): boolean;
function crypto_keyring_add_key(key_desc: string, key_data: Uint8Array | string): boolean;
/**
* Supported `context` types for this function: passphrase, key file
* @param device device to add new key to
* @param context key slot context (passphrase/keyfile/token...) to for this LUKS @device
* @param ncontext new key slot context (passphrase/keyfile/token...) to add to this LUKS @device
* @returns whether the @ncontext was successfully added to @device or not Tech category: %BD_CRYPTO_TECH_LUKS-%BD_CRYPTO_TECH_MODE_ADD_KEY
*/
function crypto_luks_add_key(
device: string,
context: CryptoKeyslotContext,
ncontext: CryptoKeyslotContext,
): boolean;
/**
* Supported `context` types for this function: passphrase, key file
* @param device device to change key of
* @param context key slot context (passphrase/keyfile/token...) for this LUKS @device
* @param ncontext new key slot context (passphrase/keyfile/token...) to add to this LUKS @device
* @returns whether the key was successfully changed or not Tech category: %BD_CRYPTO_TECH_LUKS-%BD_CRYPTO_TECH_MODE_ADD_KEY&%BD_CRYPTO_TECH_MODE_REMOVE_KEY
*/
function crypto_luks_change_key(
device: string,
context: CryptoKeyslotContext,
ncontext: CryptoKeyslotContext,
): boolean;
function crypto_luks_close(luks_device: string): boolean;
function crypto_luks_convert(device: string, target_version: CryptoLUKSVersion | null): boolean;
/**
* Formats the given `device` as LUKS according to the other parameters given. If
* `min_entropy` is specified (greater than 0), the function waits for enough
* entropy to be available in the random data pool (WHICH MAY POTENTIALLY TAKE
* FOREVER).
*
* Supported `context` types for this function: passphrase, key file
* @param device a device to format as LUKS
* @param cipher cipher specification (type-mode, e.g. "aes-xts-plain64") or %NULL to use the default
* @param key_size size of the volume key in bits or 0 to use the default
* @param context key slot context (passphrase/keyfile/token...) for this LUKS device
* @param min_entropy minimum random data entropy (in bits) required to format @device as LUKS
* @param luks_version whether to use LUKS v1 or LUKS v2
* @param extra extra arguments for LUKS format creation
* @returns whether the given @device was successfully formatted as LUKS or not (the @error) contains the error in such cases) Tech category: %BD_CRYPTO_TECH_LUKS-%BD_CRYPTO_TECH_MODE_CREATE
*/
function crypto_luks_format(
device: string,
cipher: string | null,
key_size: number,
context: CryptoKeyslotContext,
min_entropy: number,
luks_version: CryptoLUKSVersion | null,
extra?: CryptoLUKSExtra | null,
): boolean;
function crypto_luks_header_backup(device: string, backup_file: string): boolean;
function crypto_luks_header_restore(device: string, backup_file: string): boolean;
function crypto_luks_info(device: string): CryptoLUKSInfo;
/**
* Note: This can destroy last remaining keyslot without confirmation making
* the LUKS device permanently inaccessible.
* @param device device to kill slot on
* @param slot keyslot to destroy
* @returns whether the given @slot was successfully destroyed or not Tech category: %BD_CRYPTO_TECH_LUKS-%BD_CRYPTO_TECH_MODE_REMOVE_KEY
*/
function crypto_luks_kill_slot(device: string, slot: number): boolean;
/**
* Supported `context` types for this function: passphrase, key file, keyring
* @param device the device to open
* @param name name for the LUKS device
* @param context key slot context (passphrase/keyfile/token...) to open this LUKS @device
* @param read_only whether to open as read-only or not (meaning read-write)
* @returns whether the @device was successfully opened or not Tech category: %BD_CRYPTO_TECH_LUKS-%BD_CRYPTO_TECH_MODE_OPEN_CLOSE Example of using %bd_crypto_luks_open with %BDCryptoKeyslotContext: |[ BDCryptoKeyslotContext *context = NULL; context = bd_crypto_keyslot_context_new_passphrase ("passphrase", 10, NULL); bd_crypto_luks_open ("/dev/vda1", "luks-device", context, FALSE, NULL); ]|
*/
function crypto_luks_open(
device: string,
name: string,
context: CryptoKeyslotContext,
read_only: boolean,
): boolean;
/**
* Supported `context` types for this function: passphrase, key file
* @param device device to add new key to
* @param context key slot context (passphrase/keyfile/token...) to remove from this LUKS @device
* @returns whether the key was successfully removed or not Tech category: %BD_CRYPTO_TECH_LUKS-%BD_CRYPTO_TECH_MODE_REMOVE_KEY
*/
function crypto_luks_remove_key(device: string, context: CryptoKeyslotContext): boolean;
/**
* Supported `context` types for this function: passphrase, key file
* @param luks_device opened LUKS device to resize
* @param size requested size in sectors or 0 to adapt to the backing device
* @param context key slot context (passphrase/keyfile/token...) for this LUKS @device
* @returns whether the @luks_device was successfully resized or not You need to specify either @context for LUKS 2 devices that don't have verified key loaded in kernel. For LUKS 1 devices you can set @context %NULL. Tech category: %BD_CRYPTO_TECH_LUKS-%BD_CRYPTO_TECH_MODE_RESIZE
*/
function crypto_luks_resize(luks_device: string, size: number, context?: CryptoKeyslotContext | null): boolean;
/**
* Supported `context` types for this function: passphrase, key file
* @param luks_device LUKS device to resume
* @param context key slot context (passphrase/keyfile/token...) for @luks_device
* @returns whether the given @luks_device was successfully resumed or not Tech category: %BD_CRYPTO_TECH_LUKS-%BD_CRYPTO_TECH_MODE_SUSPEND_RESUME
*/
function crypto_luks_resume(luks_device: string, context?: CryptoKeyslotContext | null): boolean;
function crypto_luks_set_label(device: string, label?: string | null, subsystem?: string | null): boolean;
function crypto_luks_set_uuid(device: string, uuid?: string | null): boolean;
function crypto_luks_status(luks_device: string): string;
function crypto_luks_suspend(luks_device: string): boolean;
function crypto_luks_token_info(device: string): CryptoLUKSTokenInfo[];
/**
* Formats the given `device` as LUKS HW-OPAL according to the other parameters given. If
* `min_entropy` is specified (greater than 0), the function waits for enough
* entropy to be available in the random data pool (WHICH MAY POTENTIALLY TAKE
* FOREVER).
*
* Supported `context` types for this function: passphrase, key file
* Supported `opal_context` types for this function: passphrase
* @param device a device to format as LUKS HW-OPAL
* @param cipher cipher specification (type-mode, e.g. "aes-xts-plain64") or %NULL to use the default
* @param key_size size of the volume key in bits or 0 to use the default
* @param context key slot context (passphrase/keyfile/token...) for this LUKS device
* @param min_entropy minimum random data entropy (in bits) required to format @device as LUKS
* @param hw_encryption type of hardware encryption (SW+HW or HW only)
* @param opal_context OPAL admin passphrase
* @param extra extra arguments for LUKS format creation
* @returns whether the given @device was successfully formatted as LUKS HW-OPAL or not (the @error contains the error in such cases) Tech category: %BD_CRYPTO_TECH_LUKS-%BD_CRYPTO_TECH_MODE_CREATE
*/
function crypto_opal_format(
device: string,
cipher: string | null,
key_size: number,
context: CryptoKeyslotContext,
min_entropy: number,
hw_encryption: CryptoLUKSHWEncryptionType | null,
opal_context: CryptoKeyslotContext,
extra?: CryptoLUKSExtra | null,
): boolean;
function crypto_opal_is_supported(device: string): boolean;
function crypto_opal_reset_device(device: string, context: CryptoKeyslotContext): boolean;
function crypto_opal_wipe_device(device: string, context: CryptoKeyslotContext): boolean;
function crypto_tc_close(tc_device: string): boolean;
/**
* Supported `context` types for this function: passphrase
* @param device the device to open
* @param name name for the TrueCrypt/VeraCrypt device
* @param context passphrase key slot context for this TrueCrypt/VeraCrypt volume
* @param keyfiles paths to the keyfiles for the TrueCrypt/VeraCrypt volume
* @param hidden whether a hidden volume inside the volume should be opened
* @param system whether to try opening as an encrypted system (with boot loader)
* @param veracrypt whether to try VeraCrypt modes (TrueCrypt modes are tried anyway)
* @param veracrypt_pim VeraCrypt PIM value (only used if @veracrypt is %TRUE)
* @param read_only whether to open as read-only or not (meaning read-write)
* @returns whether the @device was successfully opened or not Tech category: %BD_CRYPTO_TECH_TRUECRYPT-%BD_CRYPTO_TECH_MODE_OPEN_CLOSE
*/
function crypto_tc_open(
device: string,
name: string,
context: CryptoKeyslotContext | null,
keyfiles: string[] | null,
hidden: boolean,
system: boolean,
veracrypt: boolean,
veracrypt_pim: number,
read_only: boolean,
): boolean;
function dm_create_linear(map_name: string, device: string, length: number, uuid?: string | null): boolean;
function dm_error_quark(): GLib.Quark;
function dm_get_subsystem_from_name(device_name: string): string;
function dm_is_tech_avail(tech: DMTech | null, mode: number): boolean;
function dm_map_exists(map_name: string, live_only: boolean, active_only: boolean): boolean;
function dm_name_from_node(dm_node: string): string;
function dm_node_from_name(map_name: string): string;
function dm_remove(map_name: string): boolean;
/**
* Checks the state of the library and if it is uninitialized or not all the
* `require_plugins` plugins are available, tries to (re)initialize it. Otherwise
* just returns early. The difference between:
*
*
* ```c
* if (!bd_is_initialized())
* bd_init(None, None, &error);
* ```
*
*
* and this function is that this function does the check and init in an atomic
* way (holding the lock preventing other threads from doing changes in
* between).
* @param require_plugins %NULL-terminated list of plugins that should be loaded (if no so_name is specified for the plugin, the default is used) or %NULL to load all plugins
* @param log_func logging function to use
* @returns whether the library was successfully initialized with all the required or default (see @require_plugins) plugins or not either before or by this call
*/
function ensure_init(require_plugins?: PluginSpec[] | null, log_func?: UtilsLogFunc | null): boolean;
/**
* Frees `args` and all its elements.
* @param args A list of %BDExtraArg to free
*/
function extra_arg_list_free(args?: ExtraArg[] | null): void;
function fs_btrfs_check(device: string, extra?: ExtraArg[] | null): boolean;
function fs_btrfs_check_label(label: string): boolean;
function fs_btrfs_check_uuid(uuid: string): boolean;
function fs_btrfs_get_info(mpoint: string): FSBtrfsInfo;
function fs_btrfs_mkfs(device: string, extra?: ExtraArg[] | null): boolean;
function fs_btrfs_repair(device: string, extra?: ExtraArg[] | null): boolean;
function fs_btrfs_resize(mpoint: string, new_size: number, extra?: ExtraArg[] | null): boolean;
function fs_btrfs_set_label(mpoint: string, label: string): boolean;
function fs_btrfs_set_uuid(device: string, uuid?: string | null): boolean;
/**
* Searches for the required utility to check the given filesystem and returns whether
* it is installed.
* Unknown filesystems or filesystems which do not support checking result in errors.
* @param type the filesystem type to be tested for installed consistency check support
* @returns whether filesystem check is available Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_can_check(type: string): [boolean, string];
/**
* Searches for the required utility to get free space of the given filesystem and
* returns whether it is installed.
* Unknown filesystems or filesystems which do not support free space querying result in errors.
* @param type the filesystem type to be tested for installed free space querying support
* @returns whether getting filesystem free space is available Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_can_get_free_space(type: string): [boolean, string];
/**
* Searches for the required utility to get info of the given filesystem and
* returns whether it is installed.
* Unknown filesystems or filesystems which do not support info querying result in errors.
* @param type the filesystem type to be tested for info querying support
* @returns whether getting filesystem info is available Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_can_get_info(type: string): [boolean, string];
/**
* Searches for the required utility to get minimum size of the given filesystem and
* returns whether it is installed.
* Unknown filesystems or filesystems which do not support minimum size querying result in errors.
* @param type the filesystem type to be tested for installed minimum size querying support
* @returns whether getting filesystem size is available Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_can_get_min_size(type: string): [boolean, string];
/**
* Searches for the required utility to get size of the given filesystem and
* returns whether it is installed.
* Unknown filesystems or filesystems which do not support size querying result in errors.
* @param type the filesystem type to be tested for installed size querying support
* @returns whether getting filesystem size is available Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_can_get_size(type: string): [boolean, string];
/**
* Searches for the required utility to create the given filesystem and returns whether
* it is installed. The options flags indicate what additional options can be specified for `type`.
* Unknown filesystems result in errors.
* @param type the filesystem type to be tested for installed mkfs support
* @returns whether filesystem mkfs tool is available Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_can_mkfs(type: string): [boolean, FSMkfsOptionsFlags, string];
/**
* Searches for the required utility to repair the given filesystem and returns whether
* it is installed.
* Unknown filesystems or filesystems which do not support reparing result in errors.
* @param type the filesystem type to be tested for installed repair support
* @returns whether filesystem repair is available Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_can_repair(type: string): [boolean, string];
/**
* Searches for the required utility to resize the given filesystem and returns whether
* it is installed. The mode flags indicate if growing and/or shrinking resize is available if
* mounted/unmounted.
* Unknown filesystems or filesystems which do not support resizing result in errors.
* @param type the filesystem type to be tested for installed resize support
* @returns whether filesystem resize is available Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_can_resize(type: string): [boolean, FSResizeFlags, string];
/**
* Searches for the required utility to set the label of the given filesystem and returns whether
* it is installed.
* Unknown filesystems or filesystems which do not support setting the label result in errors.
* @param type the filesystem type to be tested for installed label support
* @returns whether setting filesystem label is available Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_can_set_label(type: string): [boolean, string];
/**
* Searches for the required utility to set the UUID of the given filesystem and returns whether
* it is installed.
* Unknown filesystems or filesystems which do not support setting the UUID result in errors.
* @param type the filesystem type to be tested for installed UUID support
* @returns whether setting filesystem UUID is available Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_can_set_uuid(type: string): [boolean, string];
/**
* Check filesystem on `device` avoiding any modifications or repairs.
* This calls other fs check functions from this plugin based on detected
* filesystem (e.g. bd_fs_xfs_check for XFS). This function will return
* an error for unknown/unsupported filesystems.
*
* Note that depending on a corresponding filesystem type and configured
* features running this function on a mounted filesystem may result
* in false errors reported.
* @param device the device the file system of which to check
* @param fstype the filesystem type on @device or %NULL to detect
* @returns whether the file system on @device passed the consistency check or not Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_CHECK
*/
function fs_check(device: string, fstype?: string | null): boolean;
/**
* This calls other fs check label functions from this plugin based on the provided
* filesystem (e.g. bd_fs_xfs_check_label for XFS). This function will return
* an error for unknown/unsupported filesystems.
* @param fstype the filesystem type to check @label for
* @param label label to check
* @returns whether @label is a valid label for the @fstype file system or not (reason is provided in @error) Tech category: always available
*/
function fs_check_label(fstype: string, label: string): boolean;
/**
* This calls other fs check uuid functions from this plugin based on the provided
* filesystem (e.g. bd_fs_xfs_check_uuid for XFS). This function will return
* an error for unknown/unsupported filesystems.
* @param fstype the filesystem type to check @uuid for
* @param uuid uuid to check
* @returns whether @uuid is a valid UUID for the @fstype file system or not (reason is provided in @error) Tech category: always available
*/
function fs_check_uuid(fstype: string, uuid: string): boolean;
/**
* Clean all signatures from `device`.
* Difference between this and bd_fs_wipe() is that this function doesn't
* return error if `device` is already empty. This will also always remove
* all signatures from `device,` not only the first one.
* @param device the device to clean
* @param force whether to wipe signatures on a mounted @device
* @returns whether @device was successfully cleaned or not Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_WIPE
*/
function fs_clean(device: string, force: boolean): boolean;
function fs_error_quark(): GLib.Quark;
function fs_exfat_check(device: string, extra?: ExtraArg[] | null): boolean;
function fs_exfat_check_label(label: string): boolean;
function fs_exfat_check_uuid(uuid: string): boolean;
function fs_exfat_get_info(device: string): FSExfatInfo;
function fs_exfat_mkfs(device: string, extra?: ExtraArg[] | null): boolean;
function fs_exfat_repair(device: string, extra?: ExtraArg[] | null): boolean;
function fs_exfat_set_label(device: string, label: string): boolean;
function fs_exfat_set_uuid(device: string, uuid?: string | null): boolean;
function fs_ext2_check(device: string, extra?: ExtraArg[] | null): boolean;
function fs_ext2_check_label(label: string): boolean;
function fs_ext2_check_uuid(uuid: string): boolean;
function fs_ext2_get_info(device: string): FSExt2Info;
function fs_ext2_get_min_size(device: string): number;
function fs_ext2_mkfs(device: string, extra?: ExtraArg[] | null): boolean;
function fs_ext2_repair(device: string, unsafe: boolean, extra?: ExtraArg[] | null): boolean;
function fs_ext2_resize(device: string, new_size: number, extra?: ExtraArg[] | null): boolean;
function fs_ext2_set_label(device: string, label: string): boolean;
function fs_ext2_set_uuid(device: string, uuid?: string | null): boolean;
function fs_ext3_check(device: string, extra?: ExtraArg[] | null): boolean;
function fs_ext3_check_label(label: string): boolean;
function fs_ext3_check_uuid(uuid: string): boolean;
function fs_ext3_get_info(device: string): FSExt3Info;
function fs_ext3_get_min_size(device: string): number;
function fs_ext3_mkfs(device: string, extra?: ExtraArg[] | null): boolean;
function fs_ext3_repair(device: string, unsafe: boolean, extra?: ExtraArg[] | null): boolean;
function fs_ext3_resize(device: string, new_size: number, extra?: ExtraArg[] | null): boolean;
function fs_ext3_set_label(device: string, label: string): boolean;
function fs_ext3_set_uuid(device: string, uuid?: string | null): boolean;
function fs_ext4_check(device: string, extra?: ExtraArg[] | null): boolean;
function fs_ext4_check_label(label: string): boolean;
function fs_ext4_check_uuid(uuid: string): boolean;
function fs_ext4_get_info(device: string): FSExt4Info;
function fs_ext4_get_min_size(device: string): number;
function fs_ext4_mkfs(device: string, extra?: ExtraArg[] | null): boolean;
function fs_ext4_repair(device: string, unsafe: boolean, extra?: ExtraArg[] | null): boolean;
function fs_ext4_resize(device: string, new_size: number, extra?: ExtraArg[] | null): boolean;
function fs_ext4_set_label(device: string, label: string): boolean;
function fs_ext4_set_uuid(device: string, uuid?: string | null): boolean;
function fs_f2fs_check(device: string, extra?: ExtraArg[] | null): boolean;
function fs_f2fs_check_label(label: string): boolean;
function fs_f2fs_get_info(device: string): FSF2FSInfo;
function fs_f2fs_mkfs(device: string, extra?: ExtraArg[] | null): boolean;
function fs_f2fs_repair(device: string, extra?: ExtraArg[] | null): boolean;
function fs_f2fs_resize(device: string, new_size: number, safe: boolean, extra?: ExtraArg[] | null): boolean;
/**
* Returns (transfer-none): features supported by `fstype,` see %BDFSFeatures for more information.
*
* Tech category: always available
* @param fstype name of the filesystem to get features for (e.g. "ext4")
*/
function fs_features(fstype: string): FSFeatures;
/**
* Freezes filesystem mounted on `mountpoint`. The filesystem must
* support freezing.
* @param mountpoint mountpoint of the device (filesystem) to freeze
* @returns whether @mountpoint was successfully freezed or not
*/
function fs_freeze(mountpoint: string): boolean;
/**
* Get free space for filesystem on `device`. This calls other fs info functions from this
* plugin based on detected filesystem (e.g. bd_fs_ext4_get_info for ext4). This
* function will return an error for unknown/unsupported filesystems.
* @param device the device with file system to get free space for
* @param fstype the filesystem type on @device or %NULL to detect
* @returns free space of filesystem on @device, 0 in case of error. Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_get_free_space(device: string, fstype?: string | null): number;
/**
* Get first signature on `device` as a string.
* @param device the device to probe
* @returns type of filesystem found on @device, %NULL in case no signature has been detected or in case of error (@error is set in this case) Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_get_fstype(device: string): string;
/**
* Get minimum size for filesystem on `device`. This calls other fs info functions from this
* plugin based on detected filesystem (e.g. bd_fs_ext4_get_min_size for ext4). This
* function will return an error for unknown/unsupported filesystems.
* @param device the device with file system to get minimum size for
* @param fstype the filesystem type on @device or %NULL to detect
* @returns minimum size of filesystem on @device, 0 in case of error. Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_RESIZE
*/
function fs_get_min_size(device: string, fstype?: string | null): number;
/**
* Get mountpoint for `device`. If `device` is mounted multiple times only
* one mountpoint will be returned.
* @param device device to find mountpoint for
* @returns mountpoint for @device, %NULL in case device is not mounted or in case of an error (@error is set in this case) Tech category: %BD_FS_TECH_MOUNT (no mode, ignored)
*/
function fs_get_mountpoint(device: string): string;
/**
* Get size for filesystem on `device`. This calls other fs info functions from this
* plugin based on detected filesystem (e.g. bd_fs_xfs_get_info for XFS). This
* function will return an error for unknown/unsupported filesystems.
*
* Note: This function will mount `device` for filesystems that need to be mounted
* to gather information (like btrfs).
* @param device the device with file system to get size for
* @param fstype the filesystem type on @device or %NULL to detect
* @returns size of filesystem on @device, 0 in case of error. Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY
*/
function fs_get_size(device: string, fstype?: string | null): number;
function fs_is_mountpoint(path: string): boolean;
function fs_is_tech_avail(tech: FSTech | null, mode: number): boolean;
/**
* This is a helper function for creating filesystems with extra options.
* This is the same as running a filesystem-specific function like %bd_fs_ext4_mkfs
* and manually specifying the extra command line options. %BDFSMkfsOptions
* removes the need to specify supported options for selected filesystems,
* make sure to check whether `fstype` supports these options (see %bd_fs_can_mkfs)
* for details.
*
* When specifying additional mkfs options using `extra,` it's caller's
* responsibility to make sure these options do not conflict with options
* specified using `options`. Extra options are added after the `options` and
* there are no additional checks for duplicate and/or conflicting options.
* @param device the device to create the new filesystem on
* @param fstype name of the filesystem to create (e.g. "ext4")
* @param options additional options like label or UUID for the filesystem
* @param extra extra mkfs options not provided in @options
* @returns whether @fstype was successfully created on @device or not. Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_MKFS
*/
function fs_mkfs(device: string, fstype: string, options: FSMkfsOptions, extra?: ExtraArg[] | null): boolean;
function fs_mount(
device?: string | null,
mountpoint?: string | null,
fstype?: string | null,
options?: string | null,
extra?: ExtraArg[] | null,
): boolean;
function fs_nilfs2_check_label(label: string): boolean;
function fs_nilfs2_check_uuid(uuid: string): boolean;
function fs_nilfs2_get_info(device: string): FSNILFS2Info;
function fs_nilfs2_mkfs(device: string, extra?: ExtraArg[] | null): boolean;
function fs_nilfs2_resize(device: string, new_size: number): boolean;
function fs_nilfs2_set_label(device: string, label: string): boolean;
function fs_nilfs2_set_uuid(device: string, uuid?: string | null): boolean;
function fs_ntfs_check(device: string, extra?: ExtraArg[] | null): boolean;
function fs_ntfs_check_label(label: string): boolean;
function fs_ntfs_check_uuid(uuid: string): boolean;
function fs_ntfs_get_info(device: string): FSNtfsInfo;
function fs_ntfs_get_min_size(device: string): number;
function fs_ntfs_mkfs(device: string, extra?: ExtraArg[] | null): boolean;
function fs_ntfs_repair(device: string, extra?: ExtraArg[] | null): boolean;
function fs_ntfs_resize(device: string, new_size: number): boolean;
function fs_ntfs_set_label(device: string, label: string): boolean;
function fs_ntfs_set_uuid(device: string, uuid?: string | null): boolean;
/**
* Repair filesystem on `device`. This calls other fs repair functions from this
* plugin based on detected filesystem (e.g. bd_fs_xfs_repair for XFS). This
* function will return an error for unknown/unsupported filesystems.
*
* Most filesystem tools typically require the filesystem not to be mounted.
* @param device the device the file system of which to repair
* @param fstype the filesystem type on @device or %NULL to detect
* @returns whether the file system on @device was successfully repaired or not Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_REPAIR
*/
function fs_repair(device: string, fstype?: string | null): boolean;
/**
* Resize filesystem on `device`. This calls other fs resize functions from this
* plugin based on provides or detected filesystem (e.g. bd_fs_xfs_resize for XFS).
* This function will return an error for unknown/unsupported filesystems.
*
* Note: This function will mount `device` for filesystems that can be resized only
* when mounted (like XFS or Btrfs).
* @param device the device the file system of which to resize
* @param new_size new requested size for the file system (if 0, the file system is adapted to the underlying block device)
* @param fstype the filesystem type on @device or %NULL to detect
* @returns whether the file system on @device was successfully resized or not Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_RESIZE
*/
function fs_resize(device: string, new_size: number, fstype?: string | null): boolean;
/**
* Set label for filesystem on `device`. This calls other fs label functions from this
* plugin based on detected filesystem (e.g. bd_fs_xfs_set_label for XFS). This
* function will return an error for unknown/unsupported filesystems.
*
* Note: This function will mount `device` for filesystems that need to be mounted
* to set label (like btrfs).
* @param device the device with file system to set the label for
* @param label label to set
* @param fstype the filesystem type on @device or %NULL to detect
* @returns whether the file system on @device was successfully relabeled or not Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_SET_LABEL
*/
function fs_set_label(device: string, label: string, fstype?: string | null): boolean;
/**
* Set UUID for filesystem on `device`. This calls other fs UUID functions from this
* plugin based on detected filesystem (e.g. bd_fs_xfs_set_uuid for XFS). This
* function will return an error for unknown/unsupported filesystems.
* @param device the device with file system to set the UUID for
* @param uuid UUID to set or %NULL to generate a new one
* @param fstype the filesystem type on @device or %NULL to detect
* @returns whether the UUID on the file system on @device was successfully changed or not Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_SET_UUID
*/
function fs_set_uuid(device: string, uuid?: string | null, fstype?: string | null): boolean;
function fs_supported_filesystems(): string[];
/**
* Note: This checks only whether `label` adheres the length limits for Logical Volume Identifier,
* not the stricter limits for Volume Identifier.
* @param label label to check
* @returns whether @label is a valid label for the UDF file system or not (reason is provided in @error) Tech category: always available
*/
function fs_udf_check_label(label: string): boolean;
function fs_udf_check_uuid(uuid: string): boolean;
function fs_udf_get_info(device: string): FSUdfInfo;
function fs_udf_mkfs(
device: string,
media_type: string | null,
revision: string | null,
block_size: number,
extra?: ExtraArg[] | null,
): boolean;
/**
* Note: This sets both Volume Identifier and Logical Volume Identifier. Volume Identifier
* is truncated to 30 or 15 characters to accommodate to the different length limits
* of these labels.
* @param device the device containing the file system to set label for
* @param label label to set
* @returns whether the label of UDF file system on the @device was successfully set or not Tech category: %BD_FS_TECH_UDF-%BD_FS_TECH_MODE_SET_LABEL
*/
function fs_udf_set_label(device: string, label: string): boolean;
function fs_udf_set_uuid(device: string, uuid?: string | null): boolean;
/**
* Un-freezes filesystem mounted on `mountpoint`. The filesystem must
* support freezing.
* @param mountpoint mountpoint of the device (filesystem) to un-freeze
* @returns whether @mountpoint was successfully unfreezed or not
*/
function fs_unfreeze(mountpoint: string): boolean;
function fs_unmount(spec: string, lazy: boolean, force: boolean, extra?: ExtraArg[] | null): boolean;
function fs_vfat_check(device: string, extra?: ExtraArg[] | null): boolean;
function fs_vfat_check_label(label: string): boolean;
function fs_vfat_check_uuid(uuid: string): boolean;
function fs_vfat_get_info(device: string): FSVfatInfo;
/**
* Please remember that FAT labels should always be uppercase.
* @param device the device to create a new vfat fs on
* @param extra extra options for the creation (right now passed to the 'mkfs.vfat' utility)
* @returns whether a new vfat fs was successfully created on @device or not Tech category: %BD_FS_TECH_VFAT-%BD_FS_TECH_MODE_MKFS
*/
function fs_vfat_mkfs(device: string, extra?: ExtraArg[] | null): boolean;
function fs_vfat_repair(device: string, extra?: ExtraArg[] | null): boolean;
function fs_vfat_resize(device: string, new_size: number): boolean;
function fs_vfat_set_label(device: string, label: string): boolean;
function fs_vfat_set_uuid(device: string, uuid?: string | null): boolean;
function fs_wipe(device: string, all: boolean, force: boolean): boolean;
function fs_xfs_check(device: string, extra?: ExtraArg[] | null): boolean;
function fs_xfs_check_label(label: string): boolean;
function fs_xfs_check_uuid(uuid: string): boolean;
function fs_xfs_get_info(device: string): FSXfsInfo;
function fs_xfs_mkfs(device: string, extra?: ExtraArg[] | null): boolean;
function fs_xfs_repair(device: string, extra?: ExtraArg[] | null): boolean;
function fs_xfs_resize(mpoint: string, new_size: number, extra?: ExtraArg[] | null): boolean;
function fs_xfs_set_label(device: string, label: string): boolean;
function fs_xfs_set_uuid(device: string, uuid?: string | null): boolean;
function get_available_plugin_names(): string[];
function get_plugin_name(plugin: Plugin | null): string;
function get_plugin_soname(plugin: Plugin | null): string;
function init(require_plugins?: PluginSpec[] | null, log_func?: UtilsLogFunc | null): boolean;
function is_initialized(): boolean;
function is_plugin_available(plugin: Plugin | null): boolean;
function loop_error_quark(): GLib.Quark;
function loop_get_loop_name(file: string): string;
function loop_info(loop: string): LoopInfo;
function loop_is_tech_avail(tech: LoopTech | null, mode: number): boolean;
function loop_set_autoclear(loop: string, autoclear: boolean): boolean;
function loop_setup(
file: string,
offset: number,
size: number,
read_only: boolean,
part_scan: boolean,
sector_size: number,
): [boolean, string];
function loop_setup_from_fd(
fd: number,
offset: number,
size: number,
read_only: boolean,
part_scan: boolean,
sector_size: number,
): [boolean, string];
function loop_teardown(loop: string): boolean;
function lvm_add_lv_tags(vg_name: string, lv_name: string, tags: string[]): boolean;
function lvm_add_pv_tags(device: string, tags: string[]): boolean;
function lvm_add_vg_tags(vg_name: string, tags: string[]): boolean;
function lvm_cache_attach(
vg_name: string,
data_lv: string,
cache_pool_lv: string,
extra?: ExtraArg[] | null,
): boolean;
function lvm_cache_create_cached_lv(
vg_name: string,
lv_name: string,
data_size: number,
cache_size: number,
md_size: number,
mode: LVMCacheMode | null,
flags: LVMCachePoolFlags | null,
slow_pvs: string[],
fast_pvs: string[],
): boolean;
function lvm_cache_create_pool(
vg_name: string,
pool_name: string,
pool_size: number,
md_size: number,
mode: LVMCacheMode | null,
flags: LVMCachePoolFlags | null,
fast_pvs: string[],
): boolean;
function lvm_cache_detach(
vg_name: string,
cached_lv: string,
destroy: boolean,
extra?: ExtraArg[] | null,
): boolean;
function lvm_cache_get_default_md_size(cache_size: number): number;
function lvm_cache_get_mode_from_str(mode_str: string): LVMCacheMode;
function lvm_cache_get_mode_str(mode: LVMCacheMode | null): string;
/**
* Converts the `data_lv` and `metadata_lv` into a new cache pool in the `vg_name`
* VG.
* @param vg_name name of the VG to create the new thin pool in
* @param data_lv name of the LV that should become the data part of the new pool
* @param metadata_lv name of the LV that should become the metadata part of the new pool
* @param name name for the thin pool (if %NULL, the name @data_lv is inherited)
* @param extra extra options for the thin pool creation (just passed to LVM as is)
* @returns whether the new cache pool was successfully created from @data_lv and @metadata_lv or not Tech category: %BD_LVM_TECH_CACHE-%BD_LVM_TECH_MODE_CREATE
*/
function lvm_cache_pool_convert(
vg_name: string,
data_lv: string,
metadata_lv: string,
name?: string | null,
extra?: ExtraArg[] | null,
): boolean;
function lvm_cache_pool_name(vg_name: string, cached_lv: string): string;
function lvm_cache_stats(vg_name: string, cached_lv: string): LVMCacheStats;
function lvm_config_get(
section: string | null,
setting: string | null,
type: string,
values_only: boolean,
global_config: boolean,
extra?: ExtraArg[] | null,
): string;
function lvm_delete_lv_tags(vg_name: string, lv_name: string, tags: string[]): boolean;
function lvm_delete_pv_tags(device: string, tags: string[]): boolean;
function lvm_delete_vg_tags(vg_name: string, tags: string[]): boolean;
function lvm_devices_add(device: string, devices_file?: string | null, extra?: ExtraArg[] | null): boolean;
function lvm_devices_delete(device: string, devices_file?: string | null, extra?: ExtraArg[] | null): boolean;
function lvm_error_quark(): GLib.Quark;
function lvm_get_devices_filter(): string[];
function lvm_get_global_config(): string;
function lvm_get_lv_physical_size(lv_size: number, pe_size: number): number;
function lvm_get_max_lv_size(): number;
function lvm_get_supported_pe_sizes(): number[];
/**
* Note: This function will be changed in 3.0: the `n_snapshots` parameter
* is currently not used and will be removed.
* @param size size of the thin pool
* @param chunk_size chunk size of the thin pool or 0 to use the default
* @param n_snapshots ignored
* @returns recommended size of the metadata space for the specified pool Tech category: %BD_LVM_TECH_THIN_CALCS no mode (it is ignored)
*/
function lvm_get_thpool_meta_size(size: number, chunk_size: number, n_snapshots: number): number;
function lvm_get_thpool_padding(size: number, pe_size: number, included: boolean): number;
function lvm_get_vdo_compression_state_str(state: LVMVDOCompressionState | null): string;
function lvm_get_vdo_index_state_str(state: LVMVDOIndexState | null): string;
function lvm_get_vdo_operating_mode_str(mode: LVMVDOOperatingMode | null): string;
function lvm_get_vdo_write_policy_from_str(policy_str: string): LVMVDOWritePolicy;
function lvm_get_vdo_write_policy_str(policy: LVMVDOWritePolicy | null): string;
function lvm_is_supported_pe_size(size: number): boolean;
function lvm_is_tech_avail(tech: LVMTech | null, mode: number): boolean;
function lvm_is_valid_thpool_chunk_size(size: number, discard: boolean): boolean;
function lvm_is_valid_thpool_md_size(size: number): boolean;
function lvm_lvactivate(
vg_name: string,
lv_name: string,
ignore_skip: boolean,
shared: boolean,
extra?: ExtraArg[] | null,
): boolean;
function lvm_lvcreate(
vg_name: string,
lv_name: string,
size: number,
type?: string | null,
pv_list?: string[] | null,
extra?: ExtraArg[] | null,
): boolean;
function lvm_lvdeactivate(vg_name: string, lv_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_lvinfo(vg_name: string, lv_name: string): LVMLVdata;
/**
* This function will fill out the data_lvs, metadata_lvs, and segs fields as well.
* @param vg_name name of the VG that contains the LV to get information about
* @param lv_name name of the LV to get information about
* @returns information about the @vg_name/@lv_name LV or %NULL in case of error (the @error) gets populated in those cases) Tech category: %BD_LVM_TECH_BASIC-%BD_LVM_TECH_MODE_QUERY
*/
function lvm_lvinfo_tree(vg_name: string, lv_name: string): LVMLVdata;
function lvm_lvorigin(vg_name: string, lv_name: string): string;
function lvm_lvremove(vg_name: string, lv_name: string, force: boolean, extra?: ExtraArg[] | null): boolean;
function lvm_lvrename(vg_name: string, lv_name: string, new_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_lvrepair(vg_name: string, lv_name: string, pv_list: string[], extra?: ExtraArg[] | null): boolean;
function lvm_lvresize(vg_name: string, lv_name: string, size: number, extra?: ExtraArg[] | null): boolean;
function lvm_lvs(vg_name?: string | null): LVMLVdata[];
/**
* This function will fill out the data_lvs, metadata_lvs, and segs fields as well.
* @param vg_name name of the VG to get information about LVs from
* @returns information about LVs found in the given @vg_name VG or in system if @vg_name is %NULL. Tech category: %BD_LVM_TECH_BASIC-%BD_LVM_TECH_MODE_QUERY
*/
function lvm_lvs_tree(vg_name?: string | null): LVMLVdata[];
function lvm_lvsnapshotcreate(
vg_name: string,
origin_name: string,
snapshot_name: string,
size: number,
extra?: ExtraArg[] | null,
): boolean;
function lvm_lvsnapshotmerge(vg_name: string, snapshot_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_pvcreate(
device: string,
data_alignment: number,
metadata_size: number,
extra?: ExtraArg[] | null,
): boolean;
function lvm_pvinfo(device: string): LVMPVdata;
function lvm_pvmove(src: string, dest?: string | null, extra?: ExtraArg[] | null): boolean;
function lvm_pvremove(device: string, extra?: ExtraArg[] | null): boolean;
function lvm_pvresize(device: string, size: number, extra?: ExtraArg[] | null): boolean;
function lvm_pvs(): LVMPVdata[];
function lvm_pvscan(device: string | null, update_cache: boolean, extra?: ExtraArg[] | null): boolean;
function lvm_round_size_to_pe(size: number, pe_size: number, roundup: boolean): number;
function lvm_set_devices_filter(devices?: string[] | null): boolean;
/**
* Note: This function sets configuration options for LVM calls internally
* in libblockdev, it doesn't change the global lvm.conf config file.
* Calling this function with `backup {backup=0 archive=0}` for example
* means `--config=backup {backup=0 archive=0}"` will be added to all
* calls libblockdev makes.
* @param new_config string representation of the new global libblockdev LVM configuration to set or %NULL to reset to default
* @returns whether the new requested global config @new_config was successfully set or not Tech category: %BD_LVM_TECH_GLOB_CONF no mode (it is ignored)
*/
function lvm_set_global_config(new_config?: string | null): boolean;
function lvm_thlvcreate(
vg_name: string,
pool_name: string,
lv_name: string,
size: number,
extra?: ExtraArg[] | null,
): boolean;
function lvm_thlvpoolname(vg_name: string, lv_name: string): string;
/**
* Converts the `data_lv` and `metadata_lv` into a new thin pool in the `vg_name`
* VG.
* @param vg_name name of the VG to create the new thin pool in
* @param data_lv name of the LV that should become the data part of the new pool
* @param metadata_lv name of the LV that should become the metadata part of the new pool
* @param name name for the thin pool (if %NULL, the name @data_lv is inherited)
* @param extra extra options for the thin pool creation (just passed to LVM as is)
* @returns whether the new thin pool was successfully created from @data_lv and @metadata_lv or not Tech category: %BD_LVM_TECH_THIN-%BD_LVM_TECH_MODE_CREATE
*/
function lvm_thpool_convert(
vg_name: string,
data_lv: string,
metadata_lv: string,
name?: string | null,
extra?: ExtraArg[] | null,
): boolean;
function lvm_thpoolcreate(
vg_name: string,
lv_name: string,
size: number,
md_size: number,
chunk_size: number,
profile?: string | null,
extra?: ExtraArg[] | null,
): boolean;
function lvm_thsnapshotcreate(
vg_name: string,
origin_name: string,
snapshot_name: string,
pool_name?: string | null,
extra?: ExtraArg[] | null,
): boolean;
function lvm_vdo_disable_compression(vg_name: string, pool_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_vdo_disable_deduplication(vg_name: string, pool_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_vdo_enable_compression(vg_name: string, pool_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_vdo_enable_deduplication(vg_name: string, pool_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_vdo_get_stats(vg_name: string, pool_name: string): LVMVDOStats;
function lvm_vdo_get_stats_full(vg_name: string, pool_name: string): GLib.HashTable;
function lvm_vdo_info(vg_name: string, lv_name: string): LVMVDOPooldata;
/**
* Converts the `pool_lv` into a new VDO pool LV in the `vg_name` VG and creates a new
* `name` VDO LV with size `virtual_size`.
*
* Note: All data on `pool_lv` will be irreversibly destroyed.
* @param vg_name name of the VG that contains @pool_lv
* @param pool_lv name of the LV that should become the new VDO pool LV
* @param name name for the VDO LV or %NULL for default name
* @param virtual_size virtual size for the new VDO LV
* @param index_memory amount of index memory (in bytes) or 0 for default
* @param compression whether to enable compression or not
* @param deduplication whether to enable deduplication or not
* @param write_policy write policy for the volume
* @param extra extra options for the VDO pool creation (just passed to LVM as is)
* @returns whether the new VDO pool LV was successfully created from @pool_lv and or not Tech category: %BD_LVM_TECH_VDO-%BD_LVM_TECH_MODE_CREATE&%BD_LVM_TECH_MODE_MODIFY
*/
function lvm_vdo_pool_convert(
vg_name: string,
pool_lv: string,
name: string | null,
virtual_size: number,
index_memory: number,
compression: boolean,
deduplication: boolean,
write_policy: LVMVDOWritePolicy | null,
extra?: ExtraArg[] | null,
): boolean;
function lvm_vdo_pool_create(
vg_name: string,
lv_name: string,
pool_name: string | null,
data_size: number,
virtual_size: number,
index_memory: number,
compression: boolean,
deduplication: boolean,
write_policy: LVMVDOWritePolicy | null,
extra?: ExtraArg[] | null,
): boolean;
function lvm_vdo_pool_resize(
vg_name: string,
pool_name: string,
size: number,
extra?: ExtraArg[] | null,
): boolean;
function lvm_vdo_resize(vg_name: string, lv_name: string, size: number, extra?: ExtraArg[] | null): boolean;
function lvm_vdolvpoolname(vg_name: string, lv_name: string): string;
function lvm_vgactivate(vg_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_vgcreate(name: string, pv_list: string[], pe_size: number, extra?: ExtraArg[] | null): boolean;
function lvm_vgdeactivate(vg_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_vgextend(vg_name: string, device: string, extra?: ExtraArg[] | null): boolean;
function lvm_vginfo(vg_name: string): LVMVGdata;
function lvm_vglock_start(vg_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_vglock_stop(vg_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_vgreduce(vg_name: string, device?: string | null, extra?: ExtraArg[] | null): boolean;
function lvm_vgremove(vg_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_vgrename(old_vg_name: string, new_vg_name: string, extra?: ExtraArg[] | null): boolean;
function lvm_vgs(): LVMVGdata[];
function lvm_writecache_attach(
vg_name: string,
data_lv: string,
cache_lv: string,
extra?: ExtraArg[] | null,
): boolean;
function lvm_writecache_create_cached_lv(
vg_name: string,
lv_name: string,
data_size: number,
cache_size: number,
slow_pvs: string[],
fast_pvs: string[],
): boolean;
function lvm_writecache_detach(
vg_name: string,
cached_lv: string,
destroy: boolean,
extra?: ExtraArg[] | null,
): boolean;
function md_activate(
raid_spec: string | null,
members: string[] | null,
uuid: string | null,
start_degraded: boolean,
extra?: ExtraArg[] | null,
): boolean;
function md_add(raid_spec: string, device: string, raid_devs: number, extra?: ExtraArg[] | null): boolean;
function md_canonicalize_uuid(uuid: string): string;
function md_create(
device_name: string,
level: string,
disks: string[],
spares: number,
version: string | null,
bitmap: string | null,
chunk_size: number,
extra?: ExtraArg[] | null,
): boolean;
function md_deactivate(raid_spec: string): boolean;
function md_denominate(device: string): boolean;
function md_destroy(device: string): boolean;
function md_detail(raid_spec: string): MDDetailData;
function md_error_quark(): GLib.Quark;
function md_examine(device: string): MDExamineData;
function md_get_bitmap_location(raid_spec: string): string;
function md_get_md_uuid(uuid: string): string;
function md_get_status(raid_spec: string): string;
function md_get_superblock_size(member_size: number, version?: string | null): number;
function md_is_tech_avail(tech: MDTech | null, mode: number): boolean;
function md_name_from_node(node: string): string;
function md_node_from_name(name: string): string;
function md_nominate(device: string): boolean;
function md_remove(raid_spec: string, device: string, fail: boolean, extra?: ExtraArg[] | null): boolean;
function md_request_sync_action(raid_spec: string, action: string): boolean;
function md_run(raid_spec: string): boolean;
function md_set_bitmap_location(raid_spec: string, location: string): boolean;
function mpath_error_quark(): GLib.Quark;
function mpath_flush_mpaths(): boolean;
function mpath_get_mpath_members(): string[];
function mpath_is_mpath_member(device: string): boolean;
function mpath_is_tech_avail(tech: MpathTech | null, mode: number): boolean;
function mpath_set_friendly_names(enabled: boolean): boolean;
function nvdimm_error_quark(): GLib.Quark;
function nvdimm_is_tech_avail(tech: NVDIMMTech | null, mode: number): boolean;
function nvdimm_list_namespaces(
bus: string | null,
region: string | null,
idle: boolean,
extra?: ExtraArg[] | null,
): NVDIMMNamespaceInfo[];
function nvdimm_namespace_disable(namespace: string, extra?: ExtraArg[] | null): boolean;
function nvdimm_namespace_enable(namespace: string, extra?: ExtraArg[] | null): boolean;
function nvdimm_namespace_get_devname(device: string): string;
function nvdimm_namespace_get_mode_from_str(mode_str: string): NVDIMMNamespaceMode;
function nvdimm_namespace_get_mode_str(mode: NVDIMMNamespaceMode | null): string;
function nvdimm_namespace_get_supported_sector_sizes(mode: NVDIMMNamespaceMode | null): number[];
function nvdimm_namespace_info(namespace: string, extra?: ExtraArg[] | null): NVDIMMNamespaceInfo;
function nvdimm_namespace_reconfigure(
namespace: string,
mode: NVDIMMNamespaceMode | null,
force: boolean,
extra?: ExtraArg[] | null,
): boolean;
/**
* Creates a transport connection to a remote system (specified by `transport_addr` and `transport_svcid)`
* and creates a NVMe over Fabrics controller for the NVMe subsystem specified by the `subsysnqn` option.
*
* Valid values for `transport` include:
* - `"rdma"`: An rdma network (RoCE, iWARP, Infiniband, basic rdma, etc.)
* - `"fc"`: A Fibre Channel network.
* - `"tcp"`: A TCP/IP network.
* - `"loop"`: A NVMe over Fabrics target on the local host.
*
* In addition to the primary options it's possible to supply `extra` arguments:
* - `"config"`: Use the specified JSON configuration file instead of the default file (see below) or
* specify `"none"` to avoid reading any configuration file.
* - `"dhchap_key"`: NVMe In-band authentication secret in ASCII format as described
* in the NVMe 2.0 specification. When not specified, the secret is by default read
* from `/etc/nvme/hostkey`. In case that file does not exist no in-band authentication
* is attempted.
* - `"dhchap_ctrl_key"`: NVMe In-band authentication controller secret for bi-directional authentication.
* When not specified, no bi-directional authentication is attempted.
* - `"nr_io_queues"`: The number of I/O queues.
* - `"nr_write_queues"`: Number of additional queues that will be used for write I/O.
* - `"nr_poll_queues"`: Number of additional queues that will be used for polling latency sensitive I/O.
* - `"queue_size"`: Number of elements in the I/O queues.
* - `"keep_alive_tmo"`: The keep alive timeout (in seconds).
* - `"reconnect_delay"`: The delay (in seconds) before reconnect is attempted after a connect loss.
* - `"ctrl_loss_tmo"`: The controller loss timeout period (in seconds). A special value of `-1` will cause reconnecting forever.
* - `"fast_io_fail_tmo"`: Fast I/O Fail timeout (in seconds).
* - `"tos"`: Type of service.
* - `"duplicate_connect"`: Allow duplicated connections between same transport host and subsystem port. Boolean value.
* - `"disable_sqflow"`: Disables SQ flow control to omit head doorbell update for submission queues when sending nvme completions. Boolean value.
* - `"hdr_digest"`: Generates/verifies header digest (TCP). Boolean value.
* - `"data_digest"`: Generates/verifies data digest (TCP). Boolean value.
* - `"tls"`: Enable TLS encryption (TCP). Boolean value.
* - `"hostsymname"`: TP8010: NVMe host symbolic name.
* - `"keyring"`: Keyring to store and lookup keys. String value.
* - `"tls_key"`: TLS PSK for the connection. String value.
*
* Boolean values can be expressed by "0"/"1", "on"/"off" or "True"/"False" case-insensitive
* strings. Failed numerical or boolean string conversions will result in the option being ignored.
*
* By default additional options are read from the default configuration file `/etc/nvme/config.json`.
* This follows the default behaviour of `nvme-cli`. Use the `extra` `"config"` argument
* to either specify a different config file or disable use of it. The JSON configuration
* file format is documented in [https://raw.githubusercontent.com/linux-nvme/libnvme/master/doc/config-schema.json](https://raw.githubusercontent.com/linux-nvme/libnvme/master/doc/config-schema.json).
* As a rule `extra` key names are kept consistent with the JSON config file schema.
* Any `extra` option generally overrides particular option specified in a configuration file.
* @param subsysnqn The name for the NVMe subsystem to connect to.
* @param transport The network fabric used for a NVMe-over-Fabrics network.
* @param transport_addr The network address of the Controller. For transports using IP addressing (e.g. `rdma`) this should be an IP-based address.
* @param transport_svcid The transport service id. For transports using IP addressing (e.g. `rdma`) this field is the port number. By default, the IP port number for the `RDMA` transport is `4420`.
* @param host_traddr The network address used on the host to connect to the Controller. For TCP, this sets the source address on the socket.
* @param host_iface The network interface used on the host to connect to the Controller (e.g. IP `eth1`, `enp2s0`). This forces the connection to be made on a specific interface instead of letting the system decide.
* @param host_nqn Overrides the default Host NQN that identifies the NVMe Host. If this option is %NULL, the default is read from `/etc/nvme/hostnqn` first. If that does not exist, the autogenerated NQN value from the NVMe Host kernel module is used next. The Host NQN uniquely identifies the NVMe Host.
* @param host_id User-defined host UUID or %NULL to use default (as defined in `/etc/nvme/hostid`)
* @param extra Additional arguments.
* @returns %TRUE if the subsystem was connected successfully, %FALSE otherwise with @error set. Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR
*/
function nvme_connect(
subsysnqn: string,
transport: string,
transport_addr?: string | null,
transport_svcid?: string | null,
host_traddr?: string | null,
host_iface?: string | null,
host_nqn?: string | null,
host_id?: string | null,
extra?: ExtraArg[] | null,
): boolean;
/**
* Initiates or aborts the Device Self-test operation on the controller or a namespace,
* distinguished by the `device` path specified. In case a controller device
* is specified then the self-test operation would include all active namespaces.
*
* To abort a running operation, pass #BD_NVME_SELF_TEST_ACTION_ABORT as `action`.
* To retrieve progress of a current running operation, check the self-test log using
* bd_nvme_get_self_test_log().
* @param device a NVMe controller or namespace device (e.g. `/dev/nvme0`)
* @param action self-test action to take.
* @returns %TRUE if the device self-test command was issued successfully, %FALSE otherwise with @error set. Tech category: %BD_NVME_TECH_NVME-%BD_NVME_TECH_MODE_MANAGE
*/
function nvme_device_self_test(device: string, action: NVMESelfTestAction | null): boolean;
/**
* Disconnects and removes one or more existing NVMe over Fabrics controllers.
* This may disconnect multiple controllers with matching `subsysnqn` and %TRUE
* is only returned when all controllers were disconnected successfully.
* @param subsysnqn The name of the NVMe subsystem to disconnect.
* @returns %TRUE if all matching controllers were disconnected successfully, %FALSE with @error set in case of a disconnect error or when no matching controllers were found. Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR
*/
function nvme_disconnect(subsysnqn: string): boolean;
/**
* Disconnects and removes a NVMe over Fabrics controller represented
* by a block device path.
* @param path NVMe controller device to disconnect (e.g. `/dev/nvme0`).
* @returns %TRUE if the controller was disconnected successfully, %FALSE otherwise with @error set. Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR
*/
function nvme_disconnect_by_path(path: string): boolean;
function nvme_error_quark(): GLib.Quark;
/**
* A convenient utility function to look up all controllers associated
* with a NVMe subsystem the specified namespace is part of.
* @param ns_sysfs_path NVMe namespace device file.
* @param subsysnqn Limit matching to the specified subsystem NQN.
* @param host_nqn Limit matching to the specified host NQN.
* @param host_id Limit matching to the specified host ID.
* @returns list of controller sysfs paths or %NULL in case of an error (with @error set). Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR
*/
function nvme_find_ctrls_for_ns(
ns_sysfs_path: string,
subsysnqn?: string | null,
host_nqn?: string | null,
host_id?: string | null,
): string[];
/**
* Performs low level format of the NVM media, destroying all data and metadata for either
* a specific namespace or all attached namespaces to the controller. Use this command
* to change LBA sector size. Optional secure erase method can be specified as well.
*
* Supported LBA data sizes for a given namespace can be listed using the bd_nvme_get_namespace_info()
* call. In case of a special value `0` the current LBA format for a given namespace will be
* retained. When called on a controller device the first namespace is used as a reference.
*
* Note that the NVMe controller may define a Format NVM attribute indicating that the format
* operation would apply to all namespaces and a format (excluding secure erase) of any
* namespace results in a format of all namespaces in the NVM subsystem. In such case and
* when `device` is a namespace block device the #BD_NVME_ERROR_WOULD_FORMAT_ALL_NS error
* is returned to prevent further damage. This is then supposed to be handled by the caller
* and bd_nvme_format() is supposed to be called on a controller device instead.
*
* This call blocks until the format operation has finished. To retrieve progress
* of a current running operation, check the namespace info using bd_nvme_get_namespace_info().
* @param device NVMe namespace or controller device to format (e.g. `/dev/nvme0n1`)
* @param lba_data_size desired LBA data size (i.e. a sector size) in bytes or `0` to keep current. See #BDNVMELBAFormat and bd_nvme_get_namespace_info().
* @param metadata_size desired metadata size in bytes or `0` for default. See #BDNVMELBAFormat and bd_nvme_get_namespace_info().
* @param secure_erase optional secure erase action to take.
* @returns %TRUE if the format command finished successfully, %FALSE otherwise with @error set. Tech category: %BD_NVME_TECH_NVME-%BD_NVME_TECH_MODE_MANAGE
*/
function nvme_format(
device: string,
lba_data_size: number,
metadata_size: number,
secure_erase: NVMEFormatSecureErase | null,
): boolean;
/**
* Compute new Host NQN (NVM Qualified Name) value for the current system. This
* takes in account various system identifiers (DMI, device tree) with the goal
* of a stable unique identifier whenever feasible.
* @returns the Host NQN string or %NULL with @error set. Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR
*/
function nvme_generate_host_nqn(): string;
/**
* Retrieves information about the NVMe controller (the Identify Controller command)
* as specified by the `device` block device path.
* @param device a NVMe controller device (e.g. `/dev/nvme0`)
* @returns information about given controller or %NULL in case of an error (with @error set). Tech category: %BD_NVME_TECH_NVME-%BD_NVME_TECH_MODE_INFO
*/
function nvme_get_controller_info(device: string): NVMEControllerInfo;
/**
* Retrieves Error Information Log (Log Identifier `01h`) entries, used to describe
* extended error information for a command that completed with error or to report
* an error that is not specific to a particular command. This log is global to the
* controller. The ordering of the entries is based on the time when the error
* occurred, with the most recent error being returned as the first log entry.
* As the number of entries is typically limited by the drive implementation, only
* most recent entries are provided.
* @param device a NVMe controller device (e.g. `/dev/nvme0`)
* @returns null-terminated list of error entries or %NULL in case of an error (with @error set). Tech category: %BD_NVME_TECH_NVME-%BD_NVME_TECH_MODE_INFO
*/
function nvme_get_error_log_entries(device: string): NVMEErrorLogEntry[];
/**
* Reads the Host ID value from the global `/etc/nvme/hostid` file. An empty
* string is an indication that no Host ID has been set.
* @returns the Host ID string or an empty string if none set. Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR
*/
function nvme_get_host_id(): string;
/**
* Reads the Host NQN (NVM Qualified Name) value from the global `/etc/nvme/hostnqn`
* file. An empty string is an indication that no Host NQN has been set.
* @returns the Host NQN string or an empty string if none set. Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR
*/
function nvme_get_host_nqn(): string;
/**
* Retrieves information about the NVMe namespace (the Identify Namespace command)
* as specified by the `device` block device path.
* @param device a NVMe namespace device (e.g. `/dev/nvme0n1`)
* @returns information about given namespace or %NULL in case of an error (with @error set). Tech category: %BD_NVME_TECH_NVME-%BD_NVME_TECH_MODE_INFO
*/
function nvme_get_namespace_info(device: string): NVMENamespaceInfo;
/**
* Retrieves the drive sanitize status log (Log Identifier `81h`) that includes information
* about the most recent sanitize operation and the sanitize operation time estimates.
*
* As advised in the NVMe specification whitepaper the host should limit polling
* to retrieve progress of a running sanitize operations (e.g. to at most once every
* several minutes) to avoid interfering with the progress of the sanitize operation itself.
* @param device a NVMe controller device (e.g. `/dev/nvme0`)
* @returns sanitize log data or %NULL in case of an error (with @error set). Tech category: %BD_NVME_TECH_NVME-%BD_NVME_TECH_MODE_INFO
*/
function nvme_get_sanitize_log(device: string): NVMESanitizeLog;
/**
* Retrieves drive self-test log (Log Identifier `06h`). Provides the status of a self-test operation
* in progress and the percentage complete of that operation, along with the results of the last
* 20 device self-test operations.
* @param device a NVMe controller device (e.g. `/dev/nvme0`)
* @returns self-test log data or %NULL in case of an error (with @error set). Tech category: %BD_NVME_TECH_NVME-%BD_NVME_TECH_MODE_INFO
*/
function nvme_get_self_test_log(device: string): NVMESelfTestLog;
/**
* Retrieves drive SMART and general health information (Log Identifier `02h`).
* The information provided is over the life of the controller and is retained across power cycles.
* @param device a NVMe controller device (e.g. `/dev/nvme0`)
* @returns health log data or %NULL in case of an error (with @error set). Tech category: %BD_NVME_TECH_NVME-%BD_NVME_TECH_MODE_INFO
*/
function nvme_get_smart_log(device: string): NVMESmartLog;
function nvme_is_tech_avail(tech: NVMETech | null, mode: number): boolean;
/**
* Starts a sanitize operation or recovers from a previously failed sanitize operation.
* By definition, a sanitize operation alters all user data in the NVM subsystem such
* that recovery of any previous user data from any cache, the non-volatile media,
* or any Controller Memory Buffer is not possible. The scope of a sanitize operation
* is all locations in the NVM subsystem that are able to contain user data, including
* caches, Persistent Memory Regions, and unallocated or deallocated areas of the media.
*
* Once started, a sanitize operation is not able to be aborted and continues after
* a Controller Level Reset including across power cycles. Once the sanitize operation
* has run the media affected may not be immediately ready for use unless additional
* media modification mechanism is run. This is often vendor specific and also depends
* on the sanitize method (`action)` used. Callers to this sanitize operation should
* set `no_dealloc` to %TRUE for the added convenience.
*
* The controller also ignores Critical Warning(s) in the SMART / Health Information
* log page (e.g., read only mode) and attempts to complete the sanitize operation requested.
*
* This call returns immediately and the actual sanitize operation is performed
* in the background. Use bd_nvme_get_sanitize_log() to retrieve status and progress
* of a running sanitize operation. In case a sanitize operation fails the controller
* may restrict its operation until a subsequent sanitize operation is started
* (i.e. retried) or an #BD_NVME_SANITIZE_ACTION_EXIT_FAILURE action is used
* to acknowledge the failure explicitly.
*
* The `overwrite_pass_count,` `overwrite_pattern` and `overwrite_invert_pattern`
* arguments are only valid when `action` is #BD_NVME_SANITIZE_ACTION_OVERWRITE.
*
* The sanitize operation is set to run under the Allow Unrestricted Sanitize Exit
* mode.
* @param device NVMe namespace or controller device to format (e.g. `/dev/nvme0n1`)
* @param action the sanitize action to perform.
* @param no_dealloc instruct the controller to not deallocate the affected media area.
* @param overwrite_pass_count number of overwrite passes [1-15] or 0 for the default (16 passes).
* @param overwrite_pattern a 32-bit pattern used for the Overwrite sanitize operation.
* @param overwrite_invert_pattern invert the overwrite pattern between passes.
* @returns %TRUE if the format command finished successfully, %FALSE otherwise with @error set. Tech category: %BD_NVME_TECH_NVME-%BD_NVME_TECH_MODE_MANAGE
*/
function nvme_sanitize(
device: string,
action: NVMESanitizeAction | null,
no_dealloc: boolean,
overwrite_pass_count: number,
overwrite_pattern: number,
overwrite_invert_pattern: boolean,
): boolean;
function nvme_self_test_result_to_string(result: NVMESelfTestResult | null): string;
/**
* Writes the Host ID value to the system `/etc/nvme/hostid` file.
* No validation of the string is performed.
* @param host_id The Host ID.
* @returns %TRUE if the value was set successfully or %FALSE otherwise with @error set. Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR
*/
function nvme_set_host_id(host_id: string): boolean;
/**
* Writes the Host NQN (NVM Qualified Name) value to the system `/etc/nvme/hostnqn` file.
* No validation of the string is performed.
* @param host_nqn The Host NVM Qualified Name.
* @returns %TRUE if the value was set successfully or %FALSE otherwise with @error set. Tech category: %BD_NVME_TECH_FABRICS-%BD_NVME_TECH_MODE_INITIATOR
*/
function nvme_set_host_nqn(host_nqn: string): boolean;
function part_create_part(
disk: string,
type: PartTypeReq | null,
start: number,
size: number,
align: PartAlign | null,
): PartSpec;
function part_create_table(disk: string, type: PartTableType | null, ignore_existing: boolean): boolean;
function part_delete_part(disk: string, part: string): boolean;
function part_error_quark(): GLib.Quark;
function part_get_best_free_region(disk: string, type: PartType | null, size: number): PartSpec;
function part_get_disk_free_regions(disk: string): PartSpec[];
function part_get_disk_parts(disk: string): PartSpec[];
function part_get_disk_spec(disk: string): PartDiskSpec;
function part_get_part_by_pos(disk: string, position: number): PartSpec;
function part_get_part_spec(disk: string, part: string): PartSpec;
function part_get_part_table_type_str(type: PartTableType | null): string;
function part_get_type_str(type: PartType | null): string;
function part_is_tech_avail(tech: PartTech | null, mode: number): boolean;
function part_resize_part(disk: string, part: string, size: number, align: PartAlign | null): boolean;
function part_set_part_attributes(disk: string, part: string, attrs: number): boolean;
function part_set_part_bootable(disk: string, part: string, bootable: boolean): boolean;
function part_set_part_id(disk: string, part: string, part_id: string): boolean;
function part_set_part_name(disk: string, part: string, name: string): boolean;
function part_set_part_type(disk: string, part: string, type_guid: string): boolean;
function part_set_part_uuid(disk: string, part: string, uuid: string): boolean;
function reinit(require_plugins: PluginSpec[] | null, reload: boolean, log_func?: UtilsLogFunc | null): boolean;
/**
* Retrieve SMART information from the drive.
* @param device device to check.
* @param extra extra options to pass through.
* @returns ATA SMART log or %NULL in case of an error (with @error set). Tech category: %BD_SMART_TECH_ATA-%BD_SMART_TECH_MODE_INFO
*/
function smart_ata_get_info(device: string, extra?: ExtraArg[] | null): SmartATA;
/**
* Retrieve SMART information from the supplied data.
* @param data binary data to parse.
* @returns ATA SMART log or %NULL in case of an error (with @error set). Tech category: %BD_SMART_TECH_ATA-%BD_SMART_TECH_MODE_INFO
*/
function smart_ata_get_info_from_data(data: Uint8Array | string): SmartATA;
/**
* Executes or aborts device self-test.
* @param device device to trigger the test on.
* @param operation #BDSmartSelfTestOp self-test operation.
* @param extra extra options to pass through.
* @returns %TRUE when the self-test was triggered successfully or %FALSE in case of an error (with @error set). Tech category: %BD_SMART_TECH_ATA-%BD_SMART_TECH_MODE_SELFTEST
*/
function smart_device_self_test(
device: string,
operation: SmartSelfTestOp | null,
extra?: ExtraArg[] | null,
): boolean;
function smart_error_quark(): GLib.Quark;
function smart_is_tech_avail(tech: SmartTechMode | null, mode: number): boolean;
/**
* Retrieve SMART information from SCSI or SAS-compliant drive.
* @param device device to check.
* @param extra extra options to pass through.
* @returns SCSI SMART log or %NULL in case of an error (with @error set). Tech category: %BD_SMART_TECH_SCSI-%BD_SMART_TECH_MODE_INFO
*/
function smart_scsi_get_info(device: string, extra?: ExtraArg[] | null): SmartSCSI;
/**
* Enables or disables SMART functionality on device.
* @param device SMART-capable device.
* @param enabled whether to enable or disable the SMART functionality
* @param extra extra options to pass through.
* @returns %TRUE when the functionality was set successfully or %FALSE in case of an error (with @error set). Tech category: %BD_SMART_TECH_ATA-%BD_SMART_TECH_MODE_INFO
*/
function smart_set_enabled(device: string, enabled: boolean, extra?: ExtraArg[] | null): boolean;
function swap_check_label(label: string): boolean;
function swap_check_uuid(uuid: string): boolean;
function swap_error_quark(): GLib.Quark;
function swap_is_tech_avail(tech: SwapTech | null, mode: number): boolean;
function swap_mkswap(
device: string,
label?: string | null,
uuid?: string | null,
extra?: ExtraArg[] | null,
): boolean;
function swap_set_label(device: string, label: string): boolean;
function swap_set_uuid(device: string, uuid: string): boolean;
function swap_swapoff(device: string): boolean;
function swap_swapon(device: string, priority: number): boolean;
function swap_swapstatus(device: string): boolean;
function try_init(
request_plugins?: PluginSpec[] | null,
log_func?: UtilsLogFunc | null,
): [boolean, string[] | null];
function try_reinit(
require_plugins: PluginSpec[] | null,
reload: boolean,
log_func?: UtilsLogFunc | null,
): [boolean, string[] | null];
/**
* Checks whether the currently running linux kernel version is equal or higher
* than the specified required `major`.`minor`.`micro` version.
* @param major Minimal major linux kernel version.
* @param minor Minimal minor linux kernel version.
* @param micro Minimal micro linux kernel version.
* @returns an integer less than, equal to, or greater than zero, if detected version is <, == or > than the specified @major.@minor.@micro version.
*/
function utils_check_linux_version(major: number, minor: number, micro: number): number;
/**
* Note: Both supplied `version` and parsed result using `version_regexp` must be in format
* `X[.Y[.Z[.Z2[.Z3...[-R]]]]]` where all components are natural numbers, see
* %bd_utils_version_cmp for details.
* @param util name of the utility to check
* @param version minimum required version of the utility or %NULL if no version is required
* @param version_arg argument to use with the @util to get version info or %NULL to use "--version"
* @param version_regexp regexp to extract version from the version info or %NULL if only version is printed by "$ @util @version_arg"
* @returns whether the @util is available in a version >= @version or not (@error is set in such case).
*/
function utils_check_util_version(
util: string,
version?: string | null,
version_arg?: string | null,
version_regexp?: string | null,
): boolean;
function utils_dbus_service_available(
connection: Gio.DBusConnection | null,
bus_type: Gio.BusType | null,
bus_name: string,
obj_prefix: string,
): boolean;
function utils_echo_str_to_file(str: string, file_path: string): boolean;
/**
* Note that any NULL bytes read from standard output and standard error
* output will be discarded.
* @param argv the argv array for the call
* @param extra extra arguments
* @returns whether the @argv was successfully executed capturing the output or not
*/
function utils_exec_and_capture_output(argv: string[], extra: ExtraArg[] | null): [boolean, string];
function utils_exec_and_capture_output_no_progress(
argv: string[],
extra: ExtraArg[] | null,
): [boolean, string, string, number];
function utils_exec_and_report_error(argv: string[], extra?: ExtraArg[] | null): boolean;
function utils_exec_and_report_error_no_progress(argv: string[], extra?: ExtraArg[] | null): boolean;
/**
* Note that any NULL bytes read from standard output and standard error
* output are treated as separators similar to newlines and `prog_extract`
* will be called with the respective chunk.
* @param argv the argv array for the call
* @param extra extra arguments
* @param prog_extract function for extracting progress information
* @returns whether the @argv was successfully executed (no error and exit code 0) or not
*/
function utils_exec_and_report_progress(
argv: string[],
extra: ExtraArg[] | null,
prog_extract: UtilsProgExtract | null,
): [boolean, number];
function utils_exec_and_report_status_error(argv: string[], extra: ExtraArg[] | null): [boolean, number];
function utils_exec_with_input(argv: string[], input?: string | null, extra?: ExtraArg[] | null): boolean;
function utils_get_device_symlinks(dev_spec: string): string[];
/**
* Retrieves version of currently running Linux kernel. Acts also as an initializer for statically cached data.
* @returns Detected Linux kernel version or %NULL in case of an error. The returned value belongs to the library, do not free.
*/
function utils_get_linux_version(): UtilsLinuxVersion;
function utils_get_next_task_id(): number;
function utils_have_kernel_module(module_name: string): boolean;
function utils_init_logging(new_log_func?: UtilsLogFunc | null): boolean;
function utils_init_prog_reporting(new_prog_func?: UtilsProgFunc | null): boolean;
function utils_init_prog_reporting_thread(new_prog_func?: UtilsProgFunc | null): boolean;
function utils_load_kernel_module(module_name: string, options?: string | null): boolean;
function utils_log(level: number, msg: string): void;
/**
* Convenient function for logging to stdout. Can be used as #BDUtilsLogFunc.
* @param level log level
* @param msg log message
*/
function utils_log_stdout(level: number, msg: string): void;
function utils_log_task_status(task_id: number, msg: string): void;
function utils_mute_prog_reporting_thread(): boolean;
function utils_prog_reporting_initialized(): boolean;
function utils_report_finished(task_id: number, msg: string): void;
function utils_report_progress(task_id: number, completion: number, msg: string): void;
function utils_report_started(msg: string): number;
function utils_resolve_device(dev_spec: string): string;
/**
* Level of messages to log. Only messages with level <= `level` will be logged.
* For example using with #BD_UTILS_LOG_WARNING (default value) only messages
* with log levels #BD_UTILS_LOG_WARNING, #BD_UTILS_LOG_ERR, ..., #BD_UTILS_LOG_EMERG
* will be logged.
*
* Note: #BD_UTILS_LOG_DEBUG level messages are always skipped unless compiled
* with `--enable-debug` configure option.
* @param level log level
*/
function utils_set_log_level(level: number): void;
function utils_unload_kernel_module(module_name: string): boolean;
function utils_version_cmp(ver_string1: string, ver_string2: string): number;
interface UtilsLogFunc {
(level: number, msg: string): void;
}
interface UtilsProgExtract {
(line: string): boolean;
}
interface UtilsProgFunc {
(task_id: number, status: UtilsProgStatus, completion: number, msg?: string | null): void;
}
export namespace BtrfsTechMode {
export const $gtype: GObject.GType;
}
enum BtrfsTechMode {
CREATE,
DELETE,
MODIFY,
QUERY,
}
export namespace CryptoIntegrityOpenFlags {
export const $gtype: GObject.GType;
}
enum CryptoIntegrityOpenFlags {
NO_JOURNAL,
RECOVERY,
NO_JOURNAL_BITMAP,
RECALCULATE,
RECALCULATE_RESET,
ALLOW_DISCARDS,
}
export namespace CryptoTechMode {
export const $gtype: GObject.GType;
}
enum CryptoTechMode {
CREATE,
OPEN_CLOSE,
QUERY,
ADD_KEY,
REMOVE_KEY,
RESIZE,
SUSPEND_RESUME,
BACKUP_RESTORE,
MODIFY,
}
export namespace DMTechMode {
export const $gtype: GObject.GType;
}
enum DMTechMode {
CREATE_ACTIVATE,
REMOVE_DEACTIVATE,
QUERY,
}
export namespace FSConfigureFlags {
export const $gtype: GObject.GType;
}
enum FSConfigureFlags {
LABEL,
UUID,
}
export namespace FSF2FSFeature {
export const $gtype: GObject.GType;
}
enum FSF2FSFeature {
ENCRYPT,
BLKZONED,
ATOMIC_WRITE,
EXTRA_ATTR,
PRJQUOTA,
INODE_CHKSUM,
FLEXIBLE_INLINE_XATTR,
QUOTA_INO,
INODE_CRTIME,
LOST_FOUND,
VERITY,
SB_CHKSUM,
}
export namespace FSFeatureFlags {
export const $gtype: GObject.GType;
}
enum FSFeatureFlags {
OWNERS,
PARTITION_TABLE,
}
export namespace FSFsckFlags {
export const $gtype: GObject.GType;
}
enum FSFsckFlags {
CHECK,
REPAIR,
}
/**
* Flags indicating mkfs options are available for given filesystem type.
*/
/**
* Flags indicating mkfs options are available for given filesystem type.
*/
export namespace FSMkfsOptionsFlags {
export const $gtype: GObject.GType;
}
enum FSMkfsOptionsFlags {
LABEL,
UUID,
DRY_RUN,
NODISCARD,
FORCE,
NOPT,
}
/**
* Flags indicating whether a filesystem resize action supports growing and/or
* shrinking if mounted or unmounted.
*/
/**
* Flags indicating whether a filesystem resize action supports growing and/or
* shrinking if mounted or unmounted.
*/
export namespace FSResizeFlags {
export const $gtype: GObject.GType;
}
enum FSResizeFlags {
OFFLINE_SHRINK,
OFFLINE_GROW,
ONLINE_SHRINK,
ONLINE_GROW,
}
export namespace FSTechMode {
export const $gtype: GObject.GType;
}
enum FSTechMode {
MKFS,
WIPE,
CHECK,
REPAIR,
SET_LABEL,
QUERY,
RESIZE,
SET_UUID,
}
export namespace LVMCachePoolFlags {
export const $gtype: GObject.GType;
}
enum LVMCachePoolFlags {
STRIPED,
RAID1,
RAID5,
RAID6,
RAID10,
META_STRIPED,
META_RAID1,
META_RAID5,
META_RAID6,
META_RAID10,
}
export namespace LVMTechMode {
export const $gtype: GObject.GType;
}
enum LVMTechMode {
CREATE,
REMOVE,
MODIFY,
QUERY,
}
export namespace LoopTechMode {
export const $gtype: GObject.GType;
}
enum LoopTechMode {
CREATE,
DESTROY,
MODIFY,
QUERY,
}
export namespace MDTechMode {
export const $gtype: GObject.GType;
}
enum MDTechMode {
CREATE,
DELETE,
MODIFY,
QUERY,
}
export namespace MpathTechMode {
export const $gtype: GObject.GType;
}
enum MpathTechMode {
QUERY,
MODIFY,
}
export namespace NVDIMMTechMode {
export const $gtype: GObject.GType;
}
enum NVDIMMTechMode {
CREATE,
REMOVE,
ACTIVATE_DEACTIVATE,
QUERY,
RECONFIGURE,
}
export namespace NVMEControllerFeature {
export const $gtype: GObject.GType;
}
enum NVMEControllerFeature {
MULTIPORT,
MULTICTRL,
SRIOV,
ANA_REPORTING,
FORMAT,
FORMAT_ALL_NS,
NS_MGMT,
SELFTEST,
SELFTEST_SINGLE,
SANITIZE_CRYPTO,
SANITIZE_BLOCK,
SANITIZE_OVERWRITE,
SECURE_ERASE_ALL_NS,
SECURE_ERASE_CRYPTO,
STORAGE_DEVICE,
ENCLOSURE,
MGMT_PCIE,
MGMT_SMBUS,
}
export namespace NVMENamespaceFeature {
export const $gtype: GObject.GType;
}
enum NVMENamespaceFeature {
THIN,
MULTIPATH_SHARED,
FORMAT_PROGRESS,
ROTATIONAL,
}
export namespace NVMESmartCriticalWarning {
export const $gtype: GObject.GType;
}
enum NVMESmartCriticalWarning {
SPARE,
TEMPERATURE,
DEGRADED,
READONLY,
VOLATILE_MEM,
PMR_READONLY,
}
export namespace NVMETechMode {
export const $gtype: GObject.GType;
}
enum NVMETechMode {
INFO,
MANAGE,
INITIATOR,
}
export namespace PartTechMode {
export const $gtype: GObject.GType;
}
enum PartTechMode {
CREATE_TABLE,
MODIFY_TABLE,
QUERY_TABLE,
MODIFY_PART,
QUERY_PART,
}
export namespace SmartATACapabilities {
export const $gtype: GObject.GType;
}
enum SmartATACapabilities {
ATTRIBUTE_AUTOSAVE,
AUTOSAVE_TIMER,
ERROR_LOGGING,
GP_LOGGING,
}
export namespace SmartTechMode {
export const $gtype: GObject.GType;
}
enum SmartTechMode {
INFO,
SELFTEST,
}
export namespace SwapTechMode {
export const $gtype: GObject.GType;
}
enum SwapTechMode {
CREATE,
ACTIVATE_DEACTIVATE,
QUERY,
SET_LABEL,
SET_UUID,
}
class BtrfsDeviceInfo {
static $gtype: GObject.GType;
// Fields
id: number;
path: string;
size: number;
used: number;
// Constructors
constructor(
properties?: Partial<{
id: number;
path: string;
size: number;
used: number;
}>,
);
_init(...args: any[]): void;
}
class BtrfsFilesystemInfo {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
num_devices: number;
used: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
num_devices: number;
used: number;
}>,
);
_init(...args: any[]): void;
}
class BtrfsSubvolumeInfo {
static $gtype: GObject.GType;
// Fields
id: number;
parent_id: number;
path: string;
// Constructors
constructor(
properties?: Partial<{
id: number;
parent_id: number;
path: string;
}>,
);
_init(...args: any[]): void;
}
class CryptoBITLKInfo {
static $gtype: GObject.GType;
// Fields
cipher: string;
mode: string;
uuid: string;
backing_device: string;
sector_size: number;
// Constructors
constructor(
properties?: Partial<{
cipher: string;
mode: string;
uuid: string;
backing_device: string;
sector_size: number;
}>,
);
_init(...args: any[]): void;
}
class CryptoIntegrityExtra {
static $gtype: GObject.GType;
// Fields
sector_size: number;
journal_size: number;
journal_watermark: number;
journal_commit_time: number;
interleave_sectors: number;
tag_size: number;
buffer_sectors: number;
// Constructors
constructor(
properties?: Partial<{
sector_size: number;
journal_size: number;
journal_watermark: number;
journal_commit_time: number;
interleave_sectors: number;
tag_size: number;
buffer_sectors: number;
}>,
);
_init(...args: any[]): void;
static ['new'](
sector_size: number,
journal_size: number,
journal_watermark: number,
journal_commit_time: number,
interleave_sectors: number,
tag_size: number,
buffer_sectors: number,
): CryptoIntegrityExtra;
}
class CryptoIntegrityInfo {
static $gtype: GObject.GType;
// Fields
algorithm: string;
key_size: number;
sector_size: number;
tag_size: number;
interleave_sectors: number;
journal_size: number;
journal_crypt: string;
journal_integrity: string;
// Constructors
constructor(
properties?: Partial<{
algorithm: string;
key_size: number;
sector_size: number;
tag_size: number;
interleave_sectors: number;
journal_size: number;
journal_crypt: string;
journal_integrity: string;
}>,
);
_init(...args: any[]): void;
}
class CryptoKeyslotContext {
static $gtype: GObject.GType;
// Fields
type: CryptoKeyslotContextType;
// Constructors
constructor(keyfile: string, keyfile_offset: number, key_size: number);
_init(...args: any[]): void;
static new_keyfile(keyfile: string, keyfile_offset: number, key_size: number): CryptoKeyslotContext;
static new_keyring(key_desc: string): CryptoKeyslotContext;
static new_passphrase(pass_data: Uint8Array | string): CryptoKeyslotContext;
static new_volume_key(volume_key: Uint8Array | string): CryptoKeyslotContext;
}
class CryptoLUKSExtra {
static $gtype: GObject.GType;
// Fields
data_alignment: number;
data_device: string;
integrity: string;
sector_size: number;
label: string;
subsystem: string;
pbkdf: CryptoLUKSPBKDF;
// Constructors
constructor(
properties?: Partial<{
data_alignment: number;
data_device: string;
integrity: string;
sector_size: number;
label: string;
subsystem: string;
}>,
);
_init(...args: any[]): void;
static ['new'](
data_alignment: number,
data_device: string | null,
integrity: string | null,
sector_size: number,
label?: string | null,
subsystem?: string | null,
pbkdf?: CryptoLUKSPBKDF | null,
): CryptoLUKSExtra;
}
class CryptoLUKSInfo {
static $gtype: GObject.GType;
// Fields
version: CryptoLUKSVersion;
cipher: string;
mode: string;
uuid: string;
backing_device: string;
sector_size: number;
metadata_size: number;
label: string;
subsystem: string;
hw_encryption: CryptoLUKSHWEncryptionType;
// Constructors
_init(...args: any[]): void;
}
class CryptoLUKSPBKDF {
static $gtype: GObject.GType;
// Fields
type: string;
hash: string;
max_memory_kb: number;
iterations: number;
time_ms: number;
parallel_threads: number;
// Constructors
constructor(
properties?: Partial<{
type: string;
hash: string;
max_memory_kb: number;
iterations: number;
time_ms: number;
parallel_threads: number;
}>,
);
_init(...args: any[]): void;
static ['new'](
type: string | null,
hash: string | null,
max_memory_kb: number,
iterations: number,
time_ms: number,
parallel_threads: number,
): CryptoLUKSPBKDF;
}
class CryptoLUKSTokenInfo {
static $gtype: GObject.GType;
// Fields
id: number;
type: string;
keyslot: number;
// Constructors
constructor(
properties?: Partial<{
id: number;
type: string;
keyslot: number;
}>,
);
_init(...args: any[]): void;
}
/**
* See bd_extra_arg_new() for an example on how to construct the extra args.
*/
class ExtraArg {
static $gtype: GObject.GType;
// Fields
opt: string;
val: string;
// Constructors
constructor(
properties?: Partial<{
opt: string;
val: string;
}>,
);
_init(...args: any[]): void;
static ['new'](opt: string, val: string): ExtraArg;
// Static methods
/**
* Frees `args` and all its elements.
* @param args A list of %BDExtraArg to free
*/
static list_free(args?: ExtraArg[] | null): void;
// Methods
/**
* Creates a new copy of `arg`.
*/
copy(): ExtraArg;
/**
* Frees `arg`.
*/
free(): void;
}
class FSBtrfsInfo {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
size: number;
free_space: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
size: number;
free_space: number;
}>,
);
_init(...args: any[]): void;
}
class FSExfatInfo {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
sector_size: number;
sector_count: number;
cluster_count: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
sector_size: number;
sector_count: number;
cluster_count: number;
}>,
);
_init(...args: any[]): void;
}
class FSExt2Info {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
state: string;
block_size: number;
block_count: number;
free_blocks: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
state: string;
block_size: number;
block_count: number;
free_blocks: number;
}>,
);
_init(...args: any[]): void;
}
class FSExt3Info {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
state: string;
block_size: number;
block_count: number;
free_blocks: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
state: string;
block_size: number;
block_count: number;
free_blocks: number;
}>,
);
_init(...args: any[]): void;
}
class FSExt4Info {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
state: string;
block_size: number;
block_count: number;
free_blocks: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
state: string;
block_size: number;
block_count: number;
free_blocks: number;
}>,
);
_init(...args: any[]): void;
}
class FSExtInfo {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
state: string;
block_size: number;
block_count: number;
free_blocks: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
state: string;
block_size: number;
block_count: number;
free_blocks: number;
}>,
);
_init(...args: any[]): void;
}
class FSF2FSInfo {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
sector_size: number;
sector_count: number;
features: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
sector_size: number;
sector_count: number;
features: number;
}>,
);
_init(...args: any[]): void;
}
class FSFeatures {
static $gtype: GObject.GType;
// Fields
resize: FSResizeFlags;
mkfs: FSMkfsOptionsFlags;
fsck: FSFsckFlags;
configure: FSConfigureFlags;
features: FSFeatureFlags;
partition_id: string;
partition_type: string;
min_size: number;
max_size: number;
// Constructors
_init(...args: any[]): void;
}
class FSMkfsOptions {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
dry_run: boolean;
no_discard: boolean;
force: boolean;
no_pt: boolean;
reserve: Uint8Array;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
dry_run: boolean;
no_discard: boolean;
force: boolean;
no_pt: boolean;
reserve: Uint8Array;
}>,
);
_init(...args: any[]): void;
}
class FSNILFS2Info {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
size: number;
block_size: number;
free_blocks: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
size: number;
block_size: number;
free_blocks: number;
}>,
);
_init(...args: any[]): void;
}
class FSNtfsInfo {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
size: number;
free_space: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
size: number;
free_space: number;
}>,
);
_init(...args: any[]): void;
}
class FSUdfInfo {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
revision: string;
lvid: string;
vid: string;
block_size: number;
block_count: number;
free_blocks: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
revision: string;
lvid: string;
vid: string;
block_size: number;
block_count: number;
free_blocks: number;
}>,
);
_init(...args: any[]): void;
}
class FSVfatInfo {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
cluster_size: number;
cluster_count: number;
free_cluster_count: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
cluster_size: number;
cluster_count: number;
free_cluster_count: number;
}>,
);
_init(...args: any[]): void;
}
class FSXfsInfo {
static $gtype: GObject.GType;
// Fields
label: string;
uuid: string;
block_size: number;
block_count: number;
// Constructors
constructor(
properties?: Partial<{
label: string;
uuid: string;
block_size: number;
block_count: number;
}>,
);
_init(...args: any[]): void;
}
class LVMCacheStats {
static $gtype: GObject.GType;
// Fields
block_size: number;
cache_size: number;
cache_used: number;
md_block_size: number;
md_size: number;
md_used: number;
read_hits: number;
read_misses: number;
write_hits: number;
write_misses: number;
mode: LVMCacheMode;
// Constructors
_init(...args: any[]): void;
}
/**
* The `segs,` `data_lvs,` and `metadata_lvs` fields are only filled by a
* call to bd_lvm_lvinfo_tree or bd_lvm_lvs_tree. They are all NULL
* normally. If they are filled, they follow these rules:
*
* A LV is either stored directly on physical volumes, or is made up
* of sub-LVs. If it is stored on PVs, the `segs` list is non-empty
* and the `data_lvs` and `metadata_lvs` fields are both NULL. If it is
* made up of sub-LVs, then `segs` is NULL, `data_lvs` is non-empty and
* `metadata_lvs` might or might not be empty but is non-NULL. The
* sub-LVs contained in `data_lv` and `metadata_lv` are always included
* in `data_lvs` and `metadata_lvs,` respectively.
*
* For a partial LV, the `segs` list might not be complete; i.e., the
* sum of the sizes of the listed segments might not be equal to the
* size reported for the LV itself.
*
* Also, the order of entries in `segs` must be assumed to be random;
* it does not correspond to the order of segments in the logical
* volume itself.
*/
class LVMLVdata {
static $gtype: GObject.GType;
// Fields
lv_name: string;
vg_name: string;
uuid: string;
size: number;
attr: string;
segtype: string;
origin: string;
pool_lv: string;
data_lv: string;
metadata_lv: string;
roles: string;
move_pv: string;
data_percent: number;
metadata_percent: number;
copy_percent: number;
lv_tags: string[];
data_lvs: string[];
metadata_lvs: string[];
segs: LVMSEGdata[];
// Constructors
constructor(
properties?: Partial<{
lv_name: string;
vg_name: string;
uuid: string;
size: number;
attr: string;
segtype: string;
origin: string;
pool_lv: string;
data_lv: string;
metadata_lv: string;
roles: string;
move_pv: string;
data_percent: number;
metadata_percent: number;
copy_percent: number;
lv_tags: string[];
data_lvs: string[];
metadata_lvs: string[];
segs: LVMSEGdata[];
}>,
);
_init(...args: any[]): void;
}
class LVMPVdata {
static $gtype: GObject.GType;
// Fields
pv_name: string;
pv_uuid: string;
pv_free: number;
pv_size: number;
pe_start: number;
vg_name: string;
vg_uuid: string;
vg_size: number;
vg_free: number;
vg_extent_size: number;
vg_extent_count: number;
vg_free_count: number;
vg_pv_count: number;
pv_tags: string[];
missing: boolean;
// Constructors
constructor(
properties?: Partial<{
pv_name: string;
pv_uuid: string;
pv_free: number;
pv_size: number;
pe_start: number;
vg_name: string;
vg_uuid: string;
vg_size: number;
vg_free: number;
vg_extent_size: number;
vg_extent_count: number;
vg_free_count: number;
vg_pv_count: number;
pv_tags: string[];
missing: boolean;
}>,
);
_init(...args: any[]): void;
}
class LVMSEGdata {
static $gtype: GObject.GType;
// Fields
size_pe: number;
pv_start_pe: number;
pvdev: string;
// Constructors
constructor(
properties?: Partial<{
size_pe: number;
pv_start_pe: number;
pvdev: string;
}>,
);
_init(...args: any[]): void;
}
class LVMVDOPooldata {
static $gtype: GObject.GType;
// Fields
operating_mode: LVMVDOOperatingMode;
compression_state: LVMVDOCompressionState;
index_state: LVMVDOIndexState;
write_policy: LVMVDOWritePolicy;
used_size: number;
saving_percent: number;
index_memory_size: number;
deduplication: boolean;
compression: boolean;
// Constructors
_init(...args: any[]): void;
}
class LVMVDOStats {
static $gtype: GObject.GType;
// Fields
block_size: number;
logical_block_size: number;
physical_blocks: number;
data_blocks_used: number;
overhead_blocks_used: number;
logical_blocks_used: number;
used_percent: number;
saving_percent: number;
write_amplification_ratio: number;
// Constructors
constructor(
properties?: Partial<{
block_size: number;
logical_block_size: number;
physical_blocks: number;
data_blocks_used: number;
overhead_blocks_used: number;
logical_blocks_used: number;
used_percent: number;
saving_percent: number;
write_amplification_ratio: number;
}>,
);
_init(...args: any[]): void;
}
class LVMVGdata {
static $gtype: GObject.GType;
// Fields
name: string;
uuid: string;
size: number;
extent_size: number;
extent_count: number;
free_count: number;
pv_count: number;
exported: boolean;
vg_tags: string[];
// Constructors
constructor(
properties?: Partial<{
name: string;
uuid: string;
size: number;
free: number;
extent_size: number;
extent_count: number;
free_count: number;
pv_count: number;
exported: boolean;
vg_tags: string[];
}>,
);
_init(...args: any[]): void;
}
class LoopInfo {
static $gtype: GObject.GType;
// Fields
backing_file: string;
offset: number;
autoclear: boolean;
direct_io: boolean;
part_scan: boolean;
read_only: boolean;
// Constructors
constructor(
properties?: Partial<{
backing_file: string;
offset: number;
autoclear: boolean;
direct_io: boolean;
part_scan: boolean;
read_only: boolean;
}>,
);
_init(...args: any[]): void;
}
class MDDetailData {
static $gtype: GObject.GType;
// Fields
device: string;
metadata: string;
creation_time: string;
level: string;
name: string;
array_size: number;
use_dev_size: number;
raid_devices: number;
total_devices: number;
active_devices: number;
working_devices: number;
failed_devices: number;
spare_devices: number;
clean: boolean;
uuid: string;
container: string;
// Constructors
constructor(
properties?: Partial<{
device: string;
metadata: string;
creation_time: string;
level: string;
name: string;
array_size: number;
use_dev_size: number;
raid_devices: number;
total_devices: number;
active_devices: number;
working_devices: number;
failed_devices: number;
spare_devices: number;
clean: boolean;
uuid: string;
container: string;
}>,
);
_init(...args: any[]): void;
}
class MDExamineData {
static $gtype: GObject.GType;
// Fields
device: string;
level: string;
num_devices: number;
name: string;
size: number;
uuid: string;
update_time: number;
dev_uuid: string;
events: number;
metadata: string;
chunk_size: number;
// Constructors
constructor(
properties?: Partial<{
device: string;
level: string;
num_devices: number;
name: string;
size: number;
uuid: string;
update_time: number;
dev_uuid: string;
events: number;
metadata: string;
chunk_size: number;
}>,
);
_init(...args: any[]): void;
}
class NVDIMMNamespaceInfo {
static $gtype: GObject.GType;
// Fields
dev: string;
mode: number;
size: number;
uuid: string;
sector_size: number;
blockdev: string;
enabled: boolean;
// Constructors
constructor(
properties?: Partial<{
dev: string;
mode: number;
size: number;
uuid: string;
sector_size: number;
blockdev: string;
enabled: boolean;
}>,
);
_init(...args: any[]): void;
}
class NVMEControllerInfo {
static $gtype: GObject.GType;
// Fields
pci_vendor_id: number;
pci_subsys_vendor_id: number;
ctrl_id: number;
fguid: string;
model_number: string;
serial_number: string;
firmware_ver: string;
nvme_ver: string;
features: number;
controller_type: NVMEControllerType;
selftest_ext_time: number;
hmb_pref_size: number;
hmb_min_size: number;
size_total: number;
size_unalloc: number;
num_namespaces: number;
subsysnqn: string;
// Constructors
_init(...args: any[]): void;
}
class NVMEErrorLogEntry {
static $gtype: GObject.GType;
// Fields
error_count: number;
command_id: number;
command_specific: number;
command_status: number;
command_error: GLib.Error;
lba: number;
nsid: number;
transport_type: NVMETransportType;
// Constructors
_init(...args: any[]): void;
}
/**
* Namespace LBA Format Data Structure.
*/
class NVMELBAFormat {
static $gtype: GObject.GType;
// Fields
data_size: number;
metadata_size: number;
relative_performance: NVMELBAFormatRelativePerformance;
// Constructors
_init(...args: any[]): void;
}
class NVMENamespaceInfo {
static $gtype: GObject.GType;
// Fields
nsid: number;
eui64: string;
uuid: string;
nguid: string;
nsize: number;
ncap: number;
nuse: number;
features: number;
format_progress_remaining: number;
write_protected: boolean;
// Constructors
_init(...args: any[]): void;
}
class NVMESanitizeLog {
static $gtype: GObject.GType;
// Fields
sanitize_progress: number;
sanitize_status: NVMESanitizeStatus;
global_data_erased: boolean;
overwrite_passes: number;
time_for_overwrite: number;
time_for_block_erase: number;
time_for_crypto_erase: number;
time_for_overwrite_nd: number;
time_for_block_erase_nd: number;
time_for_crypto_erase_nd: number;
// Constructors
_init(...args: any[]): void;
}
class NVMESelfTestLog {
static $gtype: GObject.GType;
// Fields
current_operation: NVMESelfTestAction;
current_operation_completion: number;
// Constructors
_init(...args: any[]): void;
}
class NVMESelfTestLogEntry {
static $gtype: GObject.GType;
// Fields
result: NVMESelfTestResult;
action: NVMESelfTestAction;
segment: number;
power_on_hours: number;
nsid: number;
failing_lba: number;
status_code_error: GLib.Error;
// Constructors
_init(...args: any[]): void;
}
class NVMESmartLog {
static $gtype: GObject.GType;
// Fields
critical_warning: number;
avail_spare: number;
spare_thresh: number;
percent_used: number;
total_data_read: number;
total_data_written: number;
ctrl_busy_time: number;
power_cycles: number;
power_on_hours: number;
unsafe_shutdowns: number;
media_errors: number;
num_err_log_entries: number;
temperature: number;
temp_sensors: number[];
wctemp: number;
cctemp: number;
warning_temp_time: number;
critical_temp_time: number;
// Constructors
constructor(
properties?: Partial<{
critical_warning: number;
avail_spare: number;
spare_thresh: number;
percent_used: number;
total_data_read: number;
total_data_written: number;
ctrl_busy_time: number;
power_cycles: number;
power_on_hours: number;
unsafe_shutdowns: number;
media_errors: number;
num_err_log_entries: number;
temperature: number;
temp_sensors: number[];
wctemp: number;
cctemp: number;
warning_temp_time: number;
critical_temp_time: number;
}>,
);
_init(...args: any[]): void;
}
class PartDiskSpec {
static $gtype: GObject.GType;
// Fields
path: string;
table_type: PartTableType;
size: number;
sector_size: number;
// Constructors
_init(...args: any[]): void;
// Methods
copy(): PartDiskSpec;
free(): void;
}
class PartSpec {
static $gtype: GObject.GType;
// Fields
path: string;
name: string;
uuid: string;
id: string;
type_guid: string;
type: number;
start: number;
size: number;
bootable: boolean;
attrs: number;
type_name: string;
// Constructors
constructor(
properties?: Partial<{
path: string;
name: string;
uuid: string;
id: string;
type_guid: string;
type: number;
start: number;
size: number;
bootable: boolean;
attrs: number;
type_name: string;
}>,
);
_init(...args: any[]): void;
// Methods
copy(): PartSpec;
free(): void;
}
class PluginSpec {
static $gtype: GObject.GType;
// Fields
name: Plugin;
so_name: string;
// Constructors
constructor(name: Plugin, so_name?: string | null);
_init(...args: any[]): void;
static ['new'](name: Plugin, so_name?: string | null): PluginSpec;
}
class SmartATA {
static $gtype: GObject.GType;
// Fields
smart_supported: boolean;
smart_enabled: boolean;
overall_status_passed: boolean;
offline_data_collection_status: SmartATAOfflineDataCollectionStatus;
auto_offline_data_collection_enabled: boolean;
offline_data_collection_completion: number;
offline_data_collection_capabilities: number;
self_test_status: SmartATASelfTestStatus;
self_test_percent_remaining: number;
self_test_polling_short: number;
self_test_polling_extended: number;
self_test_polling_conveyance: number;
smart_capabilities: number;
power_on_time: number;
power_cycle_count: number;
temperature: number;
// Constructors
_init(...args: any[]): void;
// Static methods
/**
* Retrieve SMART information from the drive.
* @param device device to check.
* @param extra extra options to pass through.
*/
static get_info(device: string, extra?: ExtraArg[] | null): SmartATA;
/**
* Retrieve SMART information from the supplied data.
* @param data binary data to parse.
*/
static get_info_from_data(data: Uint8Array | string): SmartATA;
}
class SmartATAAttribute {
static $gtype: GObject.GType;
// Fields
id: number;
name: string;
well_known_name: string;
value: number;
worst: number;
threshold: number;
failed_past: boolean;
failing_now: boolean;
value_raw: number;
flags: number;
pretty_value: number;
pretty_value_unit: SmartATAAttributeUnit;
pretty_value_string: string;
// Constructors
_init(...args: any[]): void;
}
class SmartSCSI {
static $gtype: GObject.GType;
// Fields
smart_supported: boolean;
smart_enabled: boolean;
overall_status_passed: boolean;
scsi_ie: SmartSCSIInformationalException;
scsi_ie_asc: number;
scsi_ie_ascq: number;
scsi_ie_string: string;
background_scan_status: SmartSCSIBackgroundScanStatus;
background_scan_progress: number;
background_scan_runs: number;
background_medium_scan_runs: number;
read_errors_corrected_eccfast: number;
read_errors_corrected_eccdelayed: number;
read_errors_corrected_rereads: number;
read_errors_corrected_total: number;
read_errors_uncorrected: number;
read_processed_bytes: number;
write_errors_corrected_eccfast: number;
write_errors_corrected_eccdelayed: number;
write_errors_corrected_rewrites: number;
write_errors_corrected_total: number;
write_errors_uncorrected: number;
write_processed_bytes: number;
start_stop_cycle_count: number;
start_stop_cycle_lifetime: number;
load_unload_cycle_count: number;
load_unload_cycle_lifetime: number;
scsi_grown_defect_list: number;
power_on_time: number;
temperature_warning_enabled: boolean;
temperature: number;
temperature_drive_trip: number;
// Constructors
_init(...args: any[]): void;
// Static methods
/**
* Retrieve SMART information from SCSI or SAS-compliant drive.
* @param device device to check.
* @param extra extra options to pass through.
*/
static get_info(device: string, extra?: ExtraArg[] | null): SmartSCSI;
}
class UtilsLinuxVersion {
static $gtype: GObject.GType;
// Fields
major: number;
minor: number;
micro: number;
// Constructors
constructor(
properties?: Partial<{
major: number;
minor: number;
micro: number;
}>,
);
_init(...args: any[]): void;
}
/**
* Name of the imported GIR library
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
*/
const __name__: string;
/**
* Version of the imported GIR library
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
*/
const __version__: string;
}
export default BlockDev;
}
declare module 'gi://BlockDev' {
import BlockDev30 from 'gi://BlockDev?version=3.0';
export default BlockDev30;
}
// END