etc libblockdev3conf.d00-default.cfg# This is the default configuration for the libblockdev library. For # each supported technology/plugin there is a separate section/group # with the 'sonames' key. The value of the key has to be a list of # sonames of shared objects that should be attempted to be loaded for # the plugin falling back to the next one in the list. # # So this example: # [lvm] # sonames=libbd_lvm-dbus.so.0;libbd_lvm.so.0 # # would result in the libbd_lvm-dbus.so.0 shared object attempted to # be loaded and if that failed, the libbd_lvm.so.0 would be attempted # to be loaded. [btrfs] sonames=libbd_btrfs.so.3 [crypto] sonames=libbd_crypto.so.3 [dm] sonames=libbd_dm.so.3 [fs] sonames=libbd_fs.so.3 [loop] sonames=libbd_loop.so.3 [lvm] sonames=libbd_lvm.so.3 [mdraid] sonames=libbd_mdraid.so.3 [mpath] sonames=libbd_mpath.so.3 [nvdimm] sonames=libbd_nvdimm.so.3 [nvme] sonames=libbd_nvme.so.3 [part] sonames=libbd_part.so.3 [smart] sonames=libbd_smart.so.3;libbd_smartmontools.so.3 [swap] sonames=libbd_swap.so.3 [s390] sonames=libbd_s390.so.3 includeblockdev blockdev.h#include #include #ifndef BD_LIB #define BD_LIB #include "plugins.h" /** * bd_init_error_quark: (skip) */ GQuark bd_init_error_quark (void); #define BD_INIT_ERROR bd_init_error_quark () typedef enum { BD_INIT_ERROR_FAILED, BD_INIT_ERROR_PLUGINS_FAILED, BD_INIT_ERROR_NOT_IMPLEMENTED, } BDInitError; gboolean bd_init (BDPluginSpec **require_plugins, BDUtilsLogFunc log_func, GError **error); gboolean bd_ensure_init (BDPluginSpec **require_plugins, BDUtilsLogFunc log_func, GError **error); gboolean bd_reinit (BDPluginSpec **require_plugins, gboolean reload, BDUtilsLogFunc log_func, GError **error); gboolean bd_try_init(BDPluginSpec **request_plugins, BDUtilsLogFunc log_func, gchar ***loaded_plugin_names, GError **error); gboolean bd_try_reinit (BDPluginSpec **require_plugins, gboolean reload, BDUtilsLogFunc log_func, gchar ***loaded_plugin_names, GError **error); gboolean bd_is_initialized (void); #endif /* BD_LIB */ crypto.h@_#include #include #ifndef BD_CRYPTO #define BD_CRYPTO GQuark bd_crypto_error_quark (void); #define BD_CRYPTO_ERROR bd_crypto_error_quark () typedef enum { BD_CRYPTO_ERROR_TECH_UNAVAIL, BD_CRYPTO_ERROR_DEVICE, BD_CRYPTO_ERROR_STATE, BD_CRYPTO_ERROR_INVALID_SPEC, BD_CRYPTO_ERROR_FORMAT_FAILED, BD_CRYPTO_ERROR_RESIZE_FAILED, BD_CRYPTO_ERROR_RESIZE_PERM, BD_CRYPTO_ERROR_ADD_KEY, BD_CRYPTO_ERROR_REMOVE_KEY, BD_CRYPTO_ERROR_NO_KEY, BD_CRYPTO_ERROR_KEY_SLOT, BD_CRYPTO_ERROR_NSS_INIT_FAILED, BD_CRYPTO_ERROR_CERT_DECODE, BD_CRYPTO_ERROR_ESCROW_FAILED, BD_CRYPTO_ERROR_INVALID_PARAMS, BD_CRYPTO_ERROR_KEYRING, BD_CRYPTO_ERROR_KEYFILE_FAILED, BD_CRYPTO_ERROR_INVALID_CONTEXT, BD_CRYPTO_ERROR_CONVERT_FAILED, } BDCryptoError; #define BD_CRYPTO_BACKUP_PASSPHRASE_CHARSET "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz./" /* KEEP THIS A MULTIPLE OF 5 SO THAT '-' CAN BE INSERTED BETWEEN EVERY 5 CHARACTERS! */ /* 20 chars * 6 bits per char (64-item charset) = 120 "bits of security" */ #define BD_CRYPTO_BACKUP_PASSPHRASE_LENGTH 20 typedef enum { BD_CRYPTO_TECH_LUKS = 0, BD_CRYPTO_TECH_TRUECRYPT, BD_CRYPTO_TECH_ESCROW, BD_CRYPTO_TECH_INTEGRITY, BD_CRYPTO_TECH_BITLK, BD_CRYPTO_TECH_KEYRING, BD_CRYPTO_TECH_FVAULT2, BD_CRYPTO_TECH_SED_OPAL, } BDCryptoTech; typedef enum { BD_CRYPTO_TECH_MODE_CREATE = 1 << 0, BD_CRYPTO_TECH_MODE_OPEN_CLOSE = 1 << 1, BD_CRYPTO_TECH_MODE_QUERY = 1 << 2, BD_CRYPTO_TECH_MODE_ADD_KEY = 1 << 3, BD_CRYPTO_TECH_MODE_REMOVE_KEY = 1 << 4, BD_CRYPTO_TECH_MODE_RESIZE = 1 << 5, BD_CRYPTO_TECH_MODE_SUSPEND_RESUME = 1 << 6, BD_CRYPTO_TECH_MODE_BACKUP_RESTORE = 1 << 7, BD_CRYPTO_TECH_MODE_MODIFY = 1 << 8, } BDCryptoTechMode; typedef enum { BD_CRYPTO_LUKS_VERSION_LUKS1 = 0, BD_CRYPTO_LUKS_VERSION_LUKS2, } BDCryptoLUKSVersion; /** * BDCryptoLUKSPBKDF * @type: PBKDF algorithm * @hash: hash for LUKS header or NULL * @max_memory_kb: requested memory cost (in KiB) or 0 for default (benchmark) * @iterations: requested iterations or 0 for default (benchmark) * @time_ms: requested time cost or 0 for default (benchmark) * @parallel_threads: requested parallel cost (threads) or 0 for default (benchmark) */ typedef struct BDCryptoLUKSPBKDF { gchar *type; gchar *hash; guint32 max_memory_kb; guint32 iterations; guint32 time_ms; guint32 parallel_threads; } BDCryptoLUKSPBKDF; void bd_crypto_luks_pbkdf_free (BDCryptoLUKSPBKDF *pbkdf); BDCryptoLUKSPBKDF* bd_crypto_luks_pbkdf_copy (BDCryptoLUKSPBKDF *pbkdf); BDCryptoLUKSPBKDF* bd_crypto_luks_pbkdf_new (const gchar *type, const gchar *hash, guint32 max_memory_kb, guint32 iterations, guint32 time_ms, guint32 parallel_threads); /** * BDCryptoLUKSExtra: * @data_alignment: data alignment in sectors, 0 for default/auto detection * @data_device: detached encrypted data device or NULL * @integrity: integrity algorithm (e.g. "hmac-sha256") or NULL for no integrity support * Note: this field is valid only for LUKS 2 * @sector_size: encryption sector size, 0 for default (512) * Note: this field is valid only for LUKS 2 * @label: LUKS header label or NULL * Note: this field is valid only for LUKS 2 * @subsystem: LUKS header subsystem or NULL * Note: this field is valid only for LUKS 2 * @pbkdf: key derivation function specification or NULL for default * Note: this field is valid only for LUKS 2 */ typedef struct BDCryptoLUKSExtra { guint64 data_alignment; gchar *data_device; gchar *integrity; guint32 sector_size; gchar *label; gchar *subsystem; BDCryptoLUKSPBKDF *pbkdf; } BDCryptoLUKSExtra; void bd_crypto_luks_extra_free (BDCryptoLUKSExtra *extra); BDCryptoLUKSExtra* bd_crypto_luks_extra_copy (BDCryptoLUKSExtra *extra); BDCryptoLUKSExtra* bd_crypto_luks_extra_new (guint64 data_alignment, const gchar *data_device, const gchar *integrity, guint32 sector_size, const gchar *label, const gchar *subsystem, BDCryptoLUKSPBKDF *pbkdf); /** * BDCryptoIntegrityExtra: * @sector_size: integrity sector size * @journal_size: size of journal in bytes * @journal_watermark: journal flush watermark in percents; in bitmap mode sectors-per-bit * @journal_commit_time: journal commit time (or bitmap flush time) in ms * @interleave_sectors: number of interleave sectors (power of two) * @tag_size: tag size per-sector in bytes * @buffer_sectors: number of sectors in one buffer */ typedef struct BDCryptoIntegrityExtra { guint32 sector_size; guint64 journal_size; guint journal_watermark; guint journal_commit_time; guint32 interleave_sectors; guint32 tag_size; guint32 buffer_sectors; } BDCryptoIntegrityExtra; void bd_crypto_integrity_extra_free (BDCryptoIntegrityExtra *extra); BDCryptoIntegrityExtra* bd_crypto_integrity_extra_copy (BDCryptoIntegrityExtra *extra); BDCryptoIntegrityExtra* bd_crypto_integrity_extra_new (guint32 sector_size, guint64 journal_size, guint journal_watermark, guint journal_commit_time, guint64 interleave_sectors, guint64 tag_size, guint64 buffer_sectors); typedef enum { BD_CRYPTO_INTEGRITY_OPEN_NO_JOURNAL = 1 << 0, BD_CRYPTO_INTEGRITY_OPEN_RECOVERY = 1 << 1, BD_CRYPTO_INTEGRITY_OPEN_NO_JOURNAL_BITMAP = 1 << 2, BD_CRYPTO_INTEGRITY_OPEN_RECALCULATE = 1 << 3, BD_CRYPTO_INTEGRITY_OPEN_RECALCULATE_RESET = 1 << 4, BD_CRYPTO_INTEGRITY_OPEN_ALLOW_DISCARDS = 1 << 5, } BDCryptoIntegrityOpenFlags; /** * BDCryptoLUKSHWEncryptionType: * @BD_CRYPTO_LUKS_HW_ENCRYPTION_UNKNOWN: used for unknown/unsupported hardware encryption or when * error was detected when getting the information * @BD_CRYPTO_LUKS_HW_ENCRYPTION_SW_ONLY: hardware encryption is not configured on this device * @BD_CRYPTO_LUKS_HW_ENCRYPTION_OPAL_HW_ONLY: only OPAL hardware encryption is configured on this device * @BD_CRYPTO_LUKS_HW_ENCRYPTION_OPAL_HW_AND_SW: both OPAL hardware encryption and software encryption * (using LUKS/dm-crypt) is configured on this device */ typedef enum { BD_CRYPTO_LUKS_HW_ENCRYPTION_UNKNOWN = 0, BD_CRYPTO_LUKS_HW_ENCRYPTION_SW_ONLY, BD_CRYPTO_LUKS_HW_ENCRYPTION_OPAL_HW_ONLY, BD_CRYPTO_LUKS_HW_ENCRYPTION_OPAL_HW_AND_SW, } BDCryptoLUKSHWEncryptionType; typedef enum { BD_CRYPTO_LUKS_ACTIVATE_ALLOW_DISCARDS = 1 << 0, BD_CRYPTO_LUKS_ACTIVATE_SAME_CPU_CRYPT = 1 << 1, BD_CRYPTO_LUKS_ACTIVATE_SUBMIT_FROM_CRYPT_CPUS = 1 << 2, BD_CRYPTO_LUKS_ACTIVATE_NO_JOURNAL = 1 << 3, BD_CRYPTO_LUKS_ACTIVATE_NO_READ_WORKQUEUE = 1 << 4, BD_CRYPTO_LUKS_ACTIVATE_NO_WRITE_WORKQUEUE = 1 << 5, BD_CRYPTO_LUKS_ACTIVATE_HIGH_PRIORITY = 1 << 6, } BDCryptoLUKSPersistentFlags; typedef enum { BD_CRYPTO_OPEN_ALLOW_DISCARDS = 1 << 0, BD_CRYPTO_OPEN_READONLY = 1 << 1, } BDCryptoOpenFlags; /** * BDCryptoLUKSInfo: * @version: LUKS version * @cipher: used cipher (e.g. "aes") * @mode: used cipher mode (e.g. "xts-plain") * @uuid: UUID of the LUKS device * @backing_device: name of the underlying block device * @sector_size: size (in bytes) of encryption sector * Note: sector size is valid only for LUKS 2 * @metadata_size: LUKS metadata size * @label: label of the LUKS device (valid only for LUKS 2) * @subsystem: subsystem of the LUKS device (valid only for LUKS 2) * @hw_encryption: hardware encryption type */ typedef struct BDCryptoLUKSInfo { BDCryptoLUKSVersion version; gchar *cipher; gchar *mode; gchar *uuid; gchar *backing_device; guint32 sector_size; guint64 metadata_size; gchar *label; gchar *subsystem; BDCryptoLUKSHWEncryptionType hw_encryption; } BDCryptoLUKSInfo; void bd_crypto_luks_info_free (BDCryptoLUKSInfo *info); BDCryptoLUKSInfo* bd_crypto_luks_info_copy (BDCryptoLUKSInfo *info); /** * BDCryptoBITLKInfo: * @cipher: used cipher (e.g. "aes") * @mode: used cipher mode (e.g. "xts-plain") * @uuid: UUID of the BITLK device * @backing_device: name of the underlying block device * @sector_size: size (in bytes) of encryption sector */ typedef struct BDCryptoBITLKInfo { gchar *cipher; gchar *mode; gchar *uuid; gchar *backing_device; guint32 sector_size; } BDCryptoBITLKInfo; void bd_crypto_bitlk_info_free (BDCryptoBITLKInfo *info); BDCryptoBITLKInfo* bd_crypto_bitlk_info_copy (BDCryptoBITLKInfo *info); /** * BDCryptoIntegrityInfo: * @algorithm: integrity algorithm * @key_size: integrity key size in bytes * @sector_size: sector size in bytes * @tag_size: tag size per-sector in bytes * @interleave_sectors: number of interleave sectors * @journal_size: size of journal in bytes * @journal_crypt: journal encryption algorithm * @journal_integrity: journal integrity algorithm */ typedef struct BDCryptoIntegrityInfo { gchar *algorithm; guint32 key_size; guint32 sector_size; guint32 tag_size; guint32 interleave_sectors; guint64 journal_size; gchar *journal_crypt; gchar *journal_integrity; } BDCryptoIntegrityInfo; void bd_crypto_integrity_info_free (BDCryptoIntegrityInfo *info); BDCryptoIntegrityInfo* bd_crypto_integrity_info_copy (BDCryptoIntegrityInfo *info); /** * BDCryptoLUKSTokenInfo: * @id: ID of the token * @type: type of the token * @keyslot: keyslot this token is assigned to or -1 for inactive/unassigned tokens */ typedef struct BDCryptoLUKSTokenInfo { guint id; gchar *type; gint keyslot; } BDCryptoLUKSTokenInfo; void bd_crypto_luks_token_info_free (BDCryptoLUKSTokenInfo *info); BDCryptoLUKSTokenInfo* bd_crypto_luks_token_info_copy (BDCryptoLUKSTokenInfo *info); typedef struct _BDCryptoKeyslotContext BDCryptoKeyslotContext; void bd_crypto_keyslot_context_free (BDCryptoKeyslotContext *context); BDCryptoKeyslotContext* bd_crypto_keyslot_context_copy (BDCryptoKeyslotContext *context); BDCryptoKeyslotContext* bd_crypto_keyslot_context_new_passphrase (const guint8 *pass_data, gsize data_len, GError **error); BDCryptoKeyslotContext* bd_crypto_keyslot_context_new_keyfile (const gchar *keyfile, guint64 keyfile_offset, gsize key_size, GError **error); BDCryptoKeyslotContext* bd_crypto_keyslot_context_new_keyring (const gchar *key_desc, GError **error); BDCryptoKeyslotContext* bd_crypto_keyslot_context_new_volume_key (const guint8 *volume_key, gsize volume_key_size, GError **error); /* * If using the plugin as a standalone library, the following functions should * be called to: * * init() - initialize the plugin, returning TRUE on success * close() - clean after the plugin at the end or if no longer used * */ gboolean bd_crypto_init (void); void bd_crypto_close (void); gboolean bd_crypto_is_tech_avail (BDCryptoTech tech, guint64 mode, GError **error); gchar* bd_crypto_generate_backup_passphrase(GError **error); gboolean bd_crypto_device_is_luks (const gchar *device, GError **error); const gchar* bd_crypto_luks_status (const gchar *luks_device, GError **error); gboolean bd_crypto_luks_format (const gchar *device, const gchar *cipher, guint64 key_size, BDCryptoKeyslotContext *context, guint64 min_entropy, BDCryptoLUKSVersion luks_version, BDCryptoLUKSExtra *extra,GError **error); gboolean bd_crypto_luks_open (const gchar *device, const gchar *name, BDCryptoKeyslotContext *context, gboolean read_only, GError **error); gboolean bd_crypto_luks_open_flags (const gchar *device, const gchar *name, BDCryptoKeyslotContext *context, BDCryptoOpenFlags flags, GError **error); gboolean bd_crypto_luks_close (const gchar *luks_device, GError **error); gboolean bd_crypto_luks_add_key (const gchar *device, BDCryptoKeyslotContext *context, BDCryptoKeyslotContext *ncontext, GError **error); gboolean bd_crypto_luks_remove_key (const gchar *device, BDCryptoKeyslotContext *context, GError **error); gboolean bd_crypto_luks_change_key (const gchar *device, BDCryptoKeyslotContext *context, BDCryptoKeyslotContext *ncontext, GError **error); gboolean bd_crypto_luks_resize (const gchar *luks_device, guint64 size, BDCryptoKeyslotContext *context, GError **error); gboolean bd_crypto_luks_suspend (const gchar *luks_device, GError **error); gboolean bd_crypto_luks_resume (const gchar *luks_device, BDCryptoKeyslotContext *context, GError **error); gboolean bd_crypto_luks_kill_slot (const gchar *device, gint slot, GError **error); gboolean bd_crypto_luks_header_backup (const gchar *device, const gchar *backup_file, GError **error); gboolean bd_crypto_luks_header_restore (const gchar *device, const gchar *backup_file, GError **error); gboolean bd_crypto_luks_set_label (const gchar *device, const gchar *label, const gchar *subsystem, GError **error); gboolean bd_crypto_luks_check_label (const gchar *label, const gchar *subsystem, GError **error); gboolean bd_crypto_luks_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_crypto_luks_convert (const gchar *device, BDCryptoLUKSVersion target_version, GError **error); gboolean bd_crypto_luks_set_persistent_flags (const gchar *device, BDCryptoLUKSPersistentFlags flags, GError **error); BDCryptoLUKSInfo* bd_crypto_luks_info (const gchar *device, GError **error); BDCryptoBITLKInfo* bd_crypto_bitlk_info (const gchar *device, GError **error); BDCryptoIntegrityInfo* bd_crypto_integrity_info (const gchar *device, GError **error); BDCryptoLUKSTokenInfo** bd_crypto_luks_token_info (const gchar *device, GError **error); gboolean bd_crypto_integrity_format (const gchar *device, const gchar *algorithm, gboolean wipe, BDCryptoKeyslotContext *context, BDCryptoIntegrityExtra *extra, GError **error); gboolean bd_crypto_integrity_open (const gchar *device, const gchar *name, const gchar *algorithm, BDCryptoKeyslotContext *context, BDCryptoIntegrityOpenFlags flags, BDCryptoIntegrityExtra *extra, GError **error); gboolean bd_crypto_integrity_close (const gchar *integrity_device, GError **error); gboolean bd_crypto_keyring_add_key (const gchar *key_desc, const guint8 *key_data, gsize data_len, GError **error); gboolean bd_crypto_device_seems_encrypted (const gchar *device, GError **error); gboolean bd_crypto_tc_open (const gchar *device, const gchar *name, BDCryptoKeyslotContext *context, const gchar **keyfiles, gboolean hidden, gboolean system, gboolean veracrypt, guint32 veracrypt_pim, gboolean read_only, GError **error); gboolean bd_crypto_tc_open_flags (const gchar *device, const gchar *name, BDCryptoKeyslotContext *context, const gchar **keyfiles, gboolean hidden, gboolean system, gboolean veracrypt, guint32 veracrypt_pim, BDCryptoOpenFlags flags, GError **error); gboolean bd_crypto_tc_close (const gchar *tc_device, GError **error); gboolean bd_crypto_bitlk_open (const gchar *device, const gchar *name, BDCryptoKeyslotContext *context, gboolean read_only, GError **error); gboolean bd_crypto_bitlk_open_flags (const gchar *device, const gchar *name, BDCryptoKeyslotContext *context, BDCryptoOpenFlags flags, GError **error); gboolean bd_crypto_bitlk_close (const gchar *bitlk_device, GError **error); gboolean bd_crypto_fvault2_open (const gchar *device, const gchar *name, BDCryptoKeyslotContext *context, gboolean read_only, GError **error); gboolean bd_crypto_fvault2_open_flags (const gchar *device, const gchar *name, BDCryptoKeyslotContext *context, BDCryptoOpenFlags flags, GError **error); gboolean bd_crypto_fvault2_close (const gchar *fvault2_device, GError **error); gboolean bd_crypto_escrow_device (const gchar *device, const gchar *passphrase, const gchar *cert_data, const gchar *directory, const gchar *backup_passphrase, GError **error); gboolean bd_crypto_opal_is_supported (const gchar *device, GError **error); gboolean bd_crypto_opal_wipe_device (const gchar *device, BDCryptoKeyslotContext *context, GError **error); gboolean bd_crypto_opal_reset_device (const gchar *device, BDCryptoKeyslotContext *context, GError **error); gboolean bd_crypto_opal_format (const gchar *device, const gchar *cipher, guint64 key_size, BDCryptoKeyslotContext *context, guint64 min_entropy, BDCryptoLUKSHWEncryptionType hw_encryption, BDCryptoKeyslotContext *opal_context, BDCryptoLUKSExtra *extra, GError **error); #endif /* BD_CRYPTO */ dbus.h#include #include #ifndef BD_UTILS_DBUS #define BD_UTILS_DBUS GQuark bd_utils_dbus_error_quark (void); #define BD_UTILS_DBUS_ERROR bd_utils_dbus_error_quark () typedef enum { BD_UTILS_DBUS_ERROR_FAIL, BD_UTILS_DBUS_ERROR_NOEXIST, } BDUtilsDBusError; gboolean bd_utils_dbus_service_available (GDBusConnection *connection, GBusType bus_type, const gchar *bus_name, const gchar *obj_prefix, GError **error); #endif /* BD_UTILS_DBUS */ dev_utils.h/* * Copyright (C) 2017 Red Hat, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, see . * * Author: Vratislav Podzimek */ #include #ifndef BD_UTILS_DEV_UTILS #define BD_UTILS_DEV_UTILS GQuark bd_utils_dev_utils_error_quark (void); #define BD_UTILS_DEV_UTILS_ERROR bd_utils_dev_utils_error_quark () /* "C" locale to get the locale-agnostic error messages */ #define _C_LOCALE (locale_t) 0 typedef enum { BD_UTILS_DEV_UTILS_ERROR_FAILED, } BDUtilsDevUtilsError; gchar* bd_utils_resolve_device (const gchar *dev_spec, GError **error); gchar** bd_utils_get_device_symlinks (const gchar *dev_spec, GError **error); #endif /* BD_UTILS_DEV_UTILS */ exec.h #include #include "extra_arg.h" #ifndef BD_UTILS_EXEC #define BD_UTILS_EXEC typedef enum { BD_UTILS_PROG_STARTED, BD_UTILS_PROG_PROGRESS, BD_UTILS_PROG_FINISHED, } BDUtilsProgStatus; /** * BDUtilsProgFunc: * @task_id: ID of the task/action the progress is reported for * @status: progress status * @completion: percentage of completion * @msg: (nullable): arbitrary progress message (for the user) */ typedef void (*BDUtilsProgFunc) (guint64 task_id, BDUtilsProgStatus status, guint8 completion, gchar *msg); /** * BDUtilsProgExtract: * @line: line to extract progress from * @completion: (out): percentage of completion * * Callback function used to process a line captured from spawned command's standard * output and standard error output. Typically used to extract completion percentage * of a long-running job. * * Note that both outputs are read simultaneously with no guarantees of message order * this function is called with. * * The value the @completion points to may contain value previously returned from * this callback or zero when called for the first time. This is useful for extractors * where only some kind of a tick mark is printed out as a progress and previous value * is needed to compute an incremented value. It's important to keep in mind that this * function is only called over lines, i.e. progress reporting printing out tick marks * (e.g. dots) without a newline character might not work properly. * * The @line string usually contains trailing newline character, which may be absent * however in case the spawned command exits without printing one. It's guaranteed * this function is called over remaining buffer no matter what the trailing * character is. * * Returns: whether the line was a progress reporting line and should be excluded * from the collected standard output string or not. */ typedef gboolean (*BDUtilsProgExtract) (const gchar *line, guint8 *completion); GQuark bd_utils_exec_error_quark (void); #define BD_UTILS_EXEC_ERROR bd_utils_exec_error_quark () typedef enum { BD_UTILS_EXEC_ERROR_FAILED, BD_UTILS_EXEC_ERROR_NOOUT, BD_UTILS_EXEC_ERROR_INVAL_VER, BD_UTILS_EXEC_ERROR_UTIL_UNAVAILABLE, BD_UTILS_EXEC_ERROR_UTIL_UNKNOWN_VER, BD_UTILS_EXEC_ERROR_UTIL_LOW_VER, BD_UTILS_EXEC_ERROR_UTIL_CHECK_ERROR, BD_UTILS_EXEC_ERROR_UTIL_FEATURE_CHECK_ERROR, BD_UTILS_EXEC_ERROR_UTIL_FEATURE_UNAVAILABLE, } BDUtilsExecError; gboolean bd_utils_exec_and_report_error (const gchar **argv, const BDExtraArg **extra, GError **error); gboolean bd_utils_exec_and_report_error_no_progress (const gchar **argv, const BDExtraArg **extra, GError **error); gboolean bd_utils_exec_and_report_status_error (const gchar **argv, const BDExtraArg **extra, gint *status, GError **error); gboolean bd_utils_exec_and_capture_output (const gchar **argv, const BDExtraArg **extra, gchar **output, GError **error); gboolean bd_utils_exec_and_capture_output_no_progress (const gchar **argv, const BDExtraArg **extra, gchar **output, gchar **stderr, gint *status, GError **error); gboolean bd_utils_exec_and_report_progress (const gchar **argv, const BDExtraArg **extra, BDUtilsProgExtract prog_extract, gint *proc_status, GError **error); gboolean bd_utils_exec_with_input (const gchar **argv, const gchar *input, const BDExtraArg **extra, GError **error); gint bd_utils_version_cmp (const gchar *ver_string1, const gchar *ver_string2, GError **error); gboolean bd_utils_check_util_version (const gchar *util, const gchar *version, const gchar *version_arg, const gchar *version_regexp, GError **error); gboolean bd_utils_init_prog_reporting (BDUtilsProgFunc new_prog_func, GError **error); gboolean bd_utils_init_prog_reporting_thread (BDUtilsProgFunc new_prog_func, GError **error); gboolean bd_utils_mute_prog_reporting_thread (GError **error); gboolean bd_utils_prog_reporting_initialized (void); guint64 bd_utils_report_started (const gchar *msg); void bd_utils_report_progress (guint64 task_id, guint64 completion, const gchar *msg); void bd_utils_report_finished (guint64 task_id, const gchar *msg); guint64 bd_utils_get_next_task_id (void); void bd_utils_log_task_status (guint64 task_id, const gchar *msg); gboolean bd_utils_echo_str_to_file (const gchar *str, const gchar *file_path, GError **error); #endif /* BD_UTILS_EXEC */ extra_arg.hK#include #include #ifndef BD_UTILS_EXTRA_ARG #define BD_UTILS_EXTRA_ARG #define BD_UTIL_TYPE_EXTRA_ARG (bd_extra_arg_get_type ()) GType bd_extra_arg_get_type (void); /** * BDExtraArg: * @opt: extra option (command line option for most functions that allow extra options * to be passed, e.g. "-L" to call `mkfs.xfs -L`) * @val: value for @opt, can be an empty string or %NULL for options without parameter * * See bd_extra_arg_new() for an example on how to construct the extra args. */ typedef struct BDExtraArg { gchar *opt; gchar *val; } BDExtraArg; BDExtraArg* bd_extra_arg_copy (BDExtraArg *arg); void bd_extra_arg_free (BDExtraArg *arg); void bd_extra_arg_list_free (BDExtraArg **args); BDExtraArg* bd_extra_arg_new (const gchar *opt, const gchar *val); #endif /* BD_UTILS_EXTRA_ARG */ fs btrfs.hm#include #include #ifndef BD_FS_BTRFS #define BD_FS_BTRFS typedef struct BDFSBtrfsInfo { gchar *label; gchar *uuid; guint64 size; guint64 free_space; } BDFSBtrfsInfo; BDFSBtrfsInfo* bd_fs_btrfs_info_copy (BDFSBtrfsInfo *data); void bd_fs_btrfs_info_free (BDFSBtrfsInfo *data); gboolean bd_fs_btrfs_mkfs (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_btrfs_check (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_btrfs_repair (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_btrfs_set_label (const gchar *mpoint, const gchar *label, GError **error); gboolean bd_fs_btrfs_check_label (const gchar *label, GError **error); gboolean bd_fs_btrfs_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_fs_btrfs_check_uuid ( const gchar *uuid, GError **error); BDFSBtrfsInfo* bd_fs_btrfs_get_info (const gchar *mpoint, GError **error); gboolean bd_fs_btrfs_resize (const gchar *mpoint, guint64 new_size, const BDExtraArg **extra, GError **error); #endif /* BD_FS_BTRFS */ exfat.h!#include #include #ifndef BD_FS_EXFAT #define BD_FS_EXFAT typedef struct BDFSExfatInfo { gchar *label; gchar *uuid; guint64 sector_size; guint64 sector_count; guint64 cluster_count; } BDFSExfatInfo; BDFSExfatInfo* bd_fs_exfat_info_copy (BDFSExfatInfo *data); void bd_fs_exfat_info_free (BDFSExfatInfo *data); gboolean bd_fs_exfat_mkfs (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_exfat_check (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_exfat_repair (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_exfat_set_label (const gchar *device, const gchar *label, GError **error); gboolean bd_fs_exfat_check_label (const gchar *label, GError **error); gboolean bd_fs_exfat_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_fs_exfat_check_uuid (const gchar *uuid, GError **error); BDFSExfatInfo* bd_fs_exfat_get_info (const gchar *device, GError **error); #endif /* BD_FS_EXFAT */ ext.h #include #include #ifndef BD_FS_EXT #define BD_FS_EXT typedef struct BDFSExtInfo { gchar *label; gchar *uuid; gchar *state; guint64 block_size; guint64 block_count; guint64 free_blocks; } BDFSExtInfo; typedef struct BDFSExtInfo BDFSExt4Info; typedef struct BDFSExtInfo BDFSExt3Info; typedef struct BDFSExtInfo BDFSExt2Info; BDFSExt2Info* bd_fs_ext2_info_copy (BDFSExt2Info *data); void bd_fs_ext2_info_free (BDFSExt2Info *data); BDFSExt3Info* bd_fs_ext3_info_copy (BDFSExt3Info *data); void bd_fs_ext3_info_free (BDFSExt3Info *data); BDFSExt4Info* bd_fs_ext4_info_copy (BDFSExt4Info *data); void bd_fs_ext4_info_free (BDFSExt4Info *data); gboolean bd_fs_ext2_mkfs (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_ext2_check (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_ext2_repair (const gchar *device, gboolean unsafe, const BDExtraArg **extra, GError **error); gboolean bd_fs_ext2_set_label (const gchar *device, const gchar *label, GError **error); gboolean bd_fs_ext2_check_label (const gchar *label, GError **error); gboolean bd_fs_ext2_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_fs_ext2_check_uuid (const gchar *uuid, GError **error); BDFSExt2Info* bd_fs_ext2_get_info (const gchar *device, GError **error); gboolean bd_fs_ext2_resize (const gchar *device, guint64 new_size, const BDExtraArg **extra, GError **error); guint64 bd_fs_ext2_get_min_size (const gchar *device, GError **error); gboolean bd_fs_ext3_mkfs (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_ext3_check (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_ext3_repair (const gchar *device, gboolean unsafe, const BDExtraArg **extra, GError **error); gboolean bd_fs_ext3_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_fs_ext3_check_uuid (const gchar *uuid, GError **error); gboolean bd_fs_ext3_set_label (const gchar *device, const gchar *label, GError **error); gboolean bd_fs_ext3_check_label (const gchar *label, GError **error); BDFSExt3Info* bd_fs_ext3_get_info (const gchar *device, GError **error); gboolean bd_fs_ext3_resize (const gchar *device, guint64 new_size, const BDExtraArg **extra, GError **error); guint64 bd_fs_ext3_get_min_size (const gchar *device, GError **error); gboolean bd_fs_ext4_mkfs (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_ext4_check (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_ext4_repair (const gchar *device, gboolean unsafe, const BDExtraArg **extra, GError **error); gboolean bd_fs_ext4_set_label (const gchar *device, const gchar *label, GError **error); gboolean bd_fs_ext4_check_label (const gchar *label, GError **error); gboolean bd_fs_ext4_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_fs_ext4_check_uuid (const gchar *uuid, GError **error); BDFSExt4Info* bd_fs_ext4_get_info (const gchar *device, GError **error); gboolean bd_fs_ext4_resize (const gchar *device, guint64 new_size, const BDExtraArg **extra, GError **error); guint64 bd_fs_ext4_get_min_size (const gchar *device, GError **error); #endif /* BD_FS_EXT */ f2fs.hz#include #include #ifndef BD_FS_F2FS #define BD_FS_F2FS /* this is taken from f2fs_fs.h */ typedef enum { BD_FS_F2FS_FEATURE_ENCRYPT = 1 << 0, BD_FS_F2FS_FEATURE_BLKZONED = 1 << 1, BD_FS_F2FS_FEATURE_ATOMIC_WRITE = 1 << 2, BD_FS_F2FS_FEATURE_EXTRA_ATTR = 1 << 3, BD_FS_F2FS_FEATURE_PRJQUOTA = 1 << 4, BD_FS_F2FS_FEATURE_INODE_CHKSUM = 1 << 5, BD_FS_F2FS_FEATURE_FLEXIBLE_INLINE_XATTR = 1 << 6, BD_FS_F2FS_FEATURE_QUOTA_INO = 1 << 7, BD_FS_F2FS_FEATURE_INODE_CRTIME = 1 << 8, BD_FS_F2FS_FEATURE_LOST_FOUND = 1 << 9, BD_FS_F2FS_FEATURE_VERITY = 1 << 10, BD_FS_F2FS_FEATURE_SB_CHKSUM = 1 << 11, } BDFSF2FSFeature; typedef struct BDFSF2FSInfo { gchar *label; gchar *uuid; guint64 sector_size; guint64 sector_count; guint64 features; } BDFSF2FSInfo; BDFSF2FSInfo* bd_fs_f2fs_info_copy (BDFSF2FSInfo *data); void bd_fs_f2fs_info_free (BDFSF2FSInfo *data); gboolean bd_fs_f2fs_mkfs (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_f2fs_check (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_f2fs_repair (const gchar *device, const BDExtraArg **extra, GError **error); BDFSF2FSInfo* bd_fs_f2fs_get_info (const gchar *device, GError **error); gboolean bd_fs_f2fs_resize (const gchar *device, guint64 new_size, gboolean safe, const BDExtraArg **extra, GError **error); gboolean bd_fs_f2fs_check_label (const gchar *label, GError **error); #endif /* BD_FS_F2FS */ generic.h#include #ifndef BD_FS_GENERIC #define BD_FS_GENERIC gboolean bd_fs_wipe (const gchar *device, gboolean all, gboolean force, GError **error) ; gboolean bd_fs_clean (const gchar *device, gboolean force, GError **error); gchar* bd_fs_get_fstype (const gchar *device, GError **error); gboolean bd_fs_freeze (const gchar *mountpoint, GError **error); gboolean bd_fs_unfreeze (const gchar *mountpoint, GError **error); typedef enum { BD_FS_MKFS_LABEL = 1 << 0, BD_FS_MKFS_UUID = 1 << 1, BD_FS_MKFS_DRY_RUN = 1 << 2, BD_FS_MKFS_NODISCARD = 1 << 3, BD_FS_MKFS_FORCE = 1 << 4, BD_FS_MKFS_NOPT = 1 << 5, } BDFSMkfsOptionsFlags; typedef struct BDFSMkfsOptions { const gchar *label; const gchar *uuid; gboolean dry_run; gboolean no_discard; gboolean force; gboolean no_pt; guint8 reserve[32]; } BDFSMkfsOptions; BDFSMkfsOptions* bd_fs_mkfs_options_copy (BDFSMkfsOptions *data); void bd_fs_mkfs_options_free (BDFSMkfsOptions *data); const gchar** bd_fs_supported_filesystems (GError **error); gboolean bd_fs_mkfs (const gchar *device, const gchar *fstype, BDFSMkfsOptions *options, const BDExtraArg **extra, GError **error); gboolean bd_fs_resize (const gchar *device, guint64 new_size, const gchar *fstype, GError **error); gboolean bd_fs_repair (const gchar *device, const gchar *fstype, GError **error); gboolean bd_fs_check (const gchar *device, const gchar *fstype, GError **error); gboolean bd_fs_set_label (const gchar *device, const gchar *label, const gchar *fstype, GError **error); gboolean bd_fs_check_label (const gchar *fstype, const gchar *label, GError **error); gboolean bd_fs_set_uuid (const gchar *device, const gchar *uuid, const gchar *fstype, GError **error); gboolean bd_fs_check_uuid (const gchar *fstype, const gchar *uuid, GError **error); guint64 bd_fs_get_size (const gchar *device, const gchar *fstype, GError **error); guint64 bd_fs_get_free_space (const gchar *device, const gchar *fstype, GError **error); guint64 bd_fs_get_min_size (const gchar *device, const gchar *fstype, GError **error); typedef enum { BD_FS_OFFLINE_SHRINK = 1 << 1, BD_FS_OFFLINE_GROW = 1 << 2, BD_FS_ONLINE_SHRINK = 1 << 3, BD_FS_ONLINE_GROW = 1 << 4 } BDFSResizeFlags; typedef enum { BD_FS_SUPPORT_SET_LABEL = 1 << 1, BD_FS_SUPPORT_SET_UUID = 1 << 2 } BDFSConfigureFlags; typedef enum { BD_FS_FSCK_CHECK = 1 << 1, BD_FS_FSCK_REPAIR = 1 << 2 } BDFSFsckFlags; typedef enum { BD_FS_FEATURE_OWNERS = 1 << 1, BD_FS_FEATURE_PARTITION_TABLE = 1 << 2, } BDFSFeatureFlags; typedef struct BDFSFeatures { BDFSResizeFlags resize; BDFSMkfsOptionsFlags mkfs; BDFSFsckFlags fsck; BDFSConfigureFlags configure; BDFSFeatureFlags features; const gchar *partition_id; const gchar *partition_type; guint64 min_size; guint64 max_size; } BDFSFeatures; BDFSFeatures* bd_fs_features_copy (BDFSFeatures *data); void bd_fs_features_free (BDFSFeatures *data); const BDFSFeatures* bd_fs_features (const gchar *fstype, GError **error); gboolean bd_fs_can_mkfs (const gchar *type, BDFSMkfsOptionsFlags *options, gchar **required_utility, GError **error); gboolean bd_fs_can_resize (const gchar *type, BDFSResizeFlags *mode, gchar **required_utility, GError **error); gboolean bd_fs_can_check (const gchar *type, gchar **required_utility, GError **error); gboolean bd_fs_can_repair (const gchar *type, gchar **required_utility, GError **error); gboolean bd_fs_can_set_label (const gchar *type, gchar **required_utility, GError **error); gboolean bd_fs_can_set_uuid (const gchar *type, gchar **required_utility, GError **error); gboolean bd_fs_can_get_size (const gchar *type, gchar **required_utility, GError **error); gboolean bd_fs_can_get_free_space (const gchar *type, gchar **required_utility, GError **error); gboolean bd_fs_can_get_info (const gchar *type, gchar **required_utility, GError **error); gboolean bd_fs_can_get_min_size (const gchar *type, gchar **required_utility, GError **error); #endif /* BD_FS_GENERIC */ mount.h#include #include #ifndef BD_FS_MOUNT #define BD_FS_MOUNT gboolean bd_fs_unmount (const gchar *spec, gboolean lazy, gboolean force, const BDExtraArg **extra, GError **error); gboolean bd_fs_mount (const gchar *device, const gchar *mountpoint, const gchar *fstype, const gchar *options, const BDExtraArg **extra, GError **error); gchar* bd_fs_get_mountpoint (const gchar *device, GError **error); gboolean bd_fs_is_mountpoint (const gchar *path, GError **error); #endif /* BD_FS_MOUNT */ nilfs.h#include #include #ifndef BD_FS_NILFS #define BD_FS_NILFS typedef struct BDFSNILFS2Info { gchar *label; gchar *uuid; guint64 size; guint64 block_size; guint64 free_blocks; } BDFSNILFS2Info; BDFSNILFS2Info* bd_fs_nilfs2_info_copy (BDFSNILFS2Info *data); void bd_fs_nilfs2_info_free (BDFSNILFS2Info *data); gboolean bd_fs_nilfs2_mkfs (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_nilfs2_set_label (const gchar *device, const gchar *label, GError **error); gboolean bd_fs_nilfs2_check_label (const gchar *label, GError **error); gboolean bd_fs_nilfs2_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_fs_nilfs2_check_uuid (const gchar *uuid, GError **error); BDFSNILFS2Info* bd_fs_nilfs2_get_info (const gchar *device, GError **error); gboolean bd_fs_nilfs2_resize (const gchar *device, guint64 new_size, GError **error); #endif /* BD_FS_NILFS */ ntfs.h#include #include #ifndef BD_FS_NTFS #define BD_FS_NTFS typedef struct BDFSNtfsInfo { gchar *label; gchar *uuid; guint64 size; guint64 free_space; } BDFSNtfsInfo; BDFSNtfsInfo* bd_fs_ntfs_info_copy (BDFSNtfsInfo *data); void bd_fs_ntfs_info_free (BDFSNtfsInfo *data); gboolean bd_fs_ntfs_mkfs (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_ntfs_check (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_ntfs_repair (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_ntfs_set_label (const gchar *device, const gchar *label, GError **error); gboolean bd_fs_ntfs_check_label (const gchar *label, GError **error); gboolean bd_fs_ntfs_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_fs_ntfs_check_uuid ( const gchar *uuid, GError **error); BDFSNtfsInfo* bd_fs_ntfs_get_info (const gchar *device, GError **error); gboolean bd_fs_ntfs_resize (const gchar *device, guint64 new_size, GError **error); guint64 bd_fs_ntfs_get_min_size (const gchar *device, GError **error); #endif /* BD_FS_NTFS */ udf.h#include #include #ifndef BD_FS_UDF #define BD_FS_UDF typedef struct BDFSUdfInfo { gchar *label; gchar *uuid; gchar *revision; gchar *lvid; gchar *vid; guint64 block_size; guint64 block_count; guint64 free_blocks; } BDFSUdfInfo; BDFSUdfInfo* bd_fs_udf_info_copy (BDFSUdfInfo *data); void bd_fs_udf_info_free (BDFSUdfInfo *data); gboolean bd_fs_udf_mkfs (const gchar *device, const gchar *media_type, gchar *revision, guint64 block_size, const BDExtraArg **extra, GError **error); gboolean bd_fs_udf_set_label (const gchar *device, const gchar *label, GError **error); gboolean bd_fs_udf_check_label (const gchar *label, GError **error); gboolean bd_fs_udf_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_fs_udf_check_uuid ( const gchar *uuid, GError **error); BDFSUdfInfo* bd_fs_udf_get_info (const gchar *device, GError **error); #endif /* BD_FS_UDF */ vfat.hi#include #include #ifndef BD_FS_VFAT #define BD_FS_VFAT typedef struct BDFSVfatInfo { gchar *label; gchar *uuid; guint64 cluster_size; guint64 cluster_count; guint64 free_cluster_count; } BDFSVfatInfo; BDFSVfatInfo* bd_fs_vfat_info_copy (BDFSVfatInfo *data); void bd_fs_vfat_info_free (BDFSVfatInfo *data); gboolean bd_fs_vfat_mkfs (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_vfat_check (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_vfat_repair (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_vfat_set_label (const gchar *device, const gchar *label, GError **error); gboolean bd_fs_vfat_check_label (const gchar *label, GError **error); gboolean bd_fs_vfat_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_fs_vfat_check_uuid (const gchar *uuid, GError **error); BDFSVfatInfo* bd_fs_vfat_get_info (const gchar *device, GError **error); gboolean bd_fs_vfat_resize (const gchar *device, guint64 new_size, GError **error); #endif /* BD_FS_VFAT */ xfs.hK#include #include #ifndef BD_FS_XFS #define BD_FS_XFS typedef struct BDFSXfsInfo { gchar *label; gchar *uuid; guint64 block_size; guint64 block_count; } BDFSXfsInfo; BDFSXfsInfo* bd_fs_xfs_info_copy (BDFSXfsInfo *data); void bd_fs_xfs_info_free (BDFSXfsInfo *data); gboolean bd_fs_xfs_mkfs (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_xfs_check (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_xfs_repair (const gchar *device, const BDExtraArg **extra, GError **error); gboolean bd_fs_xfs_set_label (const gchar *device, const gchar *label, GError **error); gboolean bd_fs_xfs_check_label (const gchar *label, GError **error); gboolean bd_fs_xfs_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_fs_xfs_check_uuid (const gchar *uuid, GError **error); BDFSXfsInfo* bd_fs_xfs_get_info (const gchar *device, GError **error); gboolean bd_fs_xfs_resize (const gchar *mpoint, guint64 new_size, const BDExtraArg **extra, GError **error); #endif /* BD_FS_XFS */ fs.h##include #ifndef BD_FS #define BD_FS GQuark bd_fs_error_quark (void); #define BD_FS_ERROR bd_fs_error_quark () typedef enum { BD_FS_ERROR_TECH_UNAVAIL, BD_FS_ERROR_INVAL, BD_FS_ERROR_PARSE, BD_FS_ERROR_FAIL, BD_FS_ERROR_NOFS, BD_FS_ERROR_PIPE, BD_FS_ERROR_UNMOUNT_FAIL, BD_FS_ERROR_NOT_SUPPORTED, BD_FS_ERROR_NOT_MOUNTED, BD_FS_ERROR_AUTH, BD_FS_ERROR_LABEL_INVALID, BD_FS_ERROR_UUID_INVALID, BD_FS_ERROR_UNKNOWN_FS, } BDFSError; /* XXX: where the file systems start at the enum of technologies */ #define BD_FS_OFFSET 2 #define BD_FS_LAST_FS 13 typedef enum { BD_FS_TECH_GENERIC = 0, BD_FS_TECH_MOUNT = 1, BD_FS_TECH_EXT2 = 2, BD_FS_TECH_EXT3 = 3, BD_FS_TECH_EXT4 = 4, BD_FS_TECH_XFS = 5, BD_FS_TECH_VFAT = 6, BD_FS_TECH_NTFS = 7, BD_FS_TECH_F2FS = 8, BD_FS_TECH_NILFS2 = 9, BD_FS_TECH_EXFAT = 10, BD_FS_TECH_BTRFS = 11, BD_FS_TECH_UDF = 12, } BDFSTech; /* XXX: number of the highest bit of all modes */ #define BD_FS_MODE_LAST 7 typedef enum { BD_FS_TECH_MODE_MKFS = 1 << 0, BD_FS_TECH_MODE_WIPE = 1 << 1, BD_FS_TECH_MODE_CHECK = 1 << 2, BD_FS_TECH_MODE_REPAIR = 1 << 3, BD_FS_TECH_MODE_SET_LABEL = 1 << 4, BD_FS_TECH_MODE_QUERY = 1 << 5, BD_FS_TECH_MODE_RESIZE = 1 << 6, BD_FS_TECH_MODE_SET_UUID = 1 << 7, } BDFSTechMode; /* * If using the plugin as a standalone library, the following functions should * be called to: * * init() - initialize the plugin, returning TRUE on success * close() - clean after the plugin at the end or if no longer used * */ gboolean bd_fs_init (void); void bd_fs_close (void); gboolean bd_fs_is_tech_avail (BDFSTech tech, guint64 mode, GError **error); #endif /* BD_FS */ #include "fs/ext.h" #include "fs/f2fs.h" #include "fs/generic.h" #include "fs/mount.h" #include "fs/ntfs.h" #include "fs/vfat.h" #include "fs/xfs.h" #include "fs/nilfs.h" #include "fs/exfat.h" #include "fs/btrfs.h" #include "fs/udf.h" logging.hr#include #include #ifndef BD_UTILS_LOGGING #define BD_UTILS_LOGGING /* These are same as syslog levels, unfortunately GObject Introspection * doesn't work with "redefined" constants so we can't use syslog * constants here. */ #define BD_UTILS_LOG_EMERG 0 #define BD_UTILS_LOG_ALERT 1 #define BD_UTILS_LOG_CRIT 2 #define BD_UTILS_LOG_ERR 3 #define BD_UTILS_LOG_WARNING 4 #define BD_UTILS_LOG_NOTICE 5 #define BD_UTILS_LOG_INFO 6 #define BD_UTILS_LOG_DEBUG 7 /** * BDUtilsLogFunc: * @level: log level (as understood by syslog(3)) * @msg: log message * * Function type for logging function used by the libblockdev's exec utils to * log the information about program executing. */ typedef void (*BDUtilsLogFunc) (gint level, const gchar *msg); gboolean bd_utils_init_logging (BDUtilsLogFunc new_log_func, GError **error); void bd_utils_set_log_level (gint level); void bd_utils_log (gint level, const gchar *msg); void bd_utils_log_format (gint level, const gchar *format, ...) G_GNUC_PRINTF (2, 3); void bd_utils_log_stdout (gint level, const gchar *msg); #endif /* BD_UTILS_LOGGING */ loop.h#include #ifndef BD_LOOP #define BD_LOOP GQuark bd_loop_error_quark (void); #define BD_LOOP_ERROR bd_loop_error_quark () typedef enum { BD_LOOP_ERROR_TECH_UNAVAIL, BD_LOOP_ERROR_FAIL, BD_LOOP_ERROR_DEVICE, } BDLoopError; typedef enum { BD_LOOP_TECH_LOOP = 0, } BDLoopTech; typedef enum { BD_LOOP_TECH_MODE_CREATE = 1 << 0, BD_LOOP_TECH_MODE_DESTROY = 1 << 1, BD_LOOP_TECH_MODE_MODIFY = 1 << 2, BD_LOOP_TECH_MODE_QUERY = 1 << 3, } BDLoopTechMode; /** * BDLoopInfo: * @backing_file: backing file for the given loop device; * @offset: offset of the start of the device (in @backing_file); * @autoclear: whether the autoclear flag is set or not; * @direct_io: whether direct IO is enabled or not; * @part_scan: whether the partition scan is enforced or not; * @read_only: whether the device is read-only or not; */ typedef struct BDLoopInfo { gchar *backing_file; guint64 offset; gboolean autoclear; gboolean direct_io; gboolean part_scan; gboolean read_only; } BDLoopInfo; void bd_loop_info_free (BDLoopInfo *info); BDLoopInfo* bd_loop_info_copy (BDLoopInfo *info); /* * If using the plugin as a standalone library, the following functions should * be called to: * * init() - initialize the plugin, returning TRUE on success * close() - clean after the plugin at the end or if no longer used * */ gboolean bd_loop_init (void); void bd_loop_close (void); gboolean bd_loop_is_tech_avail (BDLoopTech tech, guint64 mode, GError **error); BDLoopInfo* bd_loop_info (const gchar *loop, GError **error); gchar* bd_loop_get_loop_name (const gchar *file, GError **error); gboolean bd_loop_setup (const gchar *file, guint64 offset, guint64 size, gboolean read_only, gboolean part_scan, guint64 sector_size, const gchar **loop_name, GError **error); gboolean bd_loop_setup_from_fd (gint fd, guint64 offset, guint64 size, gboolean read_only, gboolean part_scan, guint64 sector_size, const gchar **loop_name, GError **error); gboolean bd_loop_teardown (const gchar *loop, GError **error); gboolean bd_loop_set_autoclear (const gchar *loop, gboolean autoclear, GError **error); gboolean bd_loop_set_capacity (const gchar *loop, GError **error); #endif /* BD_LOOP */ mdraid.h#include #include #ifndef BD_MD #define BD_MD /* these defaults were determined empirically (taken from blivet) */ #define BD_MD_SUPERBLOCK_SIZE (2 MiB) #define BD_MD_CHUNK_SIZE (512 KiB) GQuark bd_md_error_quark (void); #define BD_MD_ERROR bd_md_error_quark () typedef enum { BD_MD_ERROR_TECH_UNAVAIL, BD_MD_ERROR_FAIL, BD_MD_ERROR_PARSE, BD_MD_ERROR_BAD_FORMAT, BD_MD_ERROR_NO_MATCH, BD_MD_ERROR_INVAL, } BDMDError; typedef struct BDMDExamineData { gchar *device; gchar *level; guint64 num_devices; gchar *name; guint64 size; gchar *uuid; guint64 update_time; gchar *dev_uuid; guint64 events; gchar *metadata; guint64 chunk_size; } BDMDExamineData; BDMDExamineData* bd_md_examine_data_copy (BDMDExamineData *data); void bd_md_examine_data_free (BDMDExamineData *data); typedef struct BDMDDetailData { gchar *device; gchar *metadata; gchar *creation_time; gchar *level; gchar *name; guint64 array_size; guint64 use_dev_size; guint64 raid_devices; guint64 total_devices; guint64 active_devices; guint64 working_devices; guint64 failed_devices; guint64 spare_devices; gboolean clean; gchar *uuid; gchar *container; } BDMDDetailData; void bd_md_detail_data_free (BDMDDetailData *data); BDMDDetailData* bd_md_detail_data_copy (BDMDDetailData *data); typedef enum { BD_MD_TECH_MDRAID = 0, } BDMDTech; typedef enum { BD_MD_TECH_MODE_CREATE = 1 << 0, BD_MD_TECH_MODE_DELETE = 1 << 1, BD_MD_TECH_MODE_MODIFY = 1 << 2, BD_MD_TECH_MODE_QUERY = 1 << 3, } BDMDTechMode; /* * If using the plugin as a standalone library, the following functions should * be called to: * * init() - initialize the plugin, returning TRUE on success * close() - clean after the plugin at the end or if no longer used * */ gboolean bd_md_init (void); void bd_md_close (void); gboolean bd_md_is_tech_avail (BDMDTech tech, guint64 mode, GError **error); guint64 bd_md_get_superblock_size (guint64 member_size, const gchar *version, GError **error); gboolean bd_md_create (const gchar *device_name, const gchar *level, const gchar **disks, guint64 spares, const gchar *version, const gchar *bitmap, guint64 chunk_size, const BDExtraArg **extra, GError **error); gboolean bd_md_destroy (const gchar *device, GError **error); gboolean bd_md_deactivate (const gchar *raid_spec, GError **error); gboolean bd_md_activate (const gchar *raid_spec, const gchar **members, const gchar *uuid, gboolean start_degraded, const BDExtraArg **extra, GError **error); gboolean bd_md_run (const gchar *raid_spec, GError **error); gboolean bd_md_nominate (const gchar *device, GError **error); gboolean bd_md_denominate (const gchar *device, GError **error); gboolean bd_md_add (const gchar *raid_spec, const gchar *device, guint64 raid_devs, const BDExtraArg **extra, GError **error); gboolean bd_md_remove (const gchar *raid_spec, const gchar *device, gboolean fail, const BDExtraArg **extra, GError **error); BDMDExamineData* bd_md_examine (const gchar *device, GError **error); BDMDDetailData* bd_md_detail (const gchar *raid_spec, GError **error); gchar* bd_md_canonicalize_uuid (const gchar *uuid, GError **error); gchar* bd_md_get_md_uuid (const gchar *uuid, GError **error); gchar* bd_md_node_from_name (const gchar *name, GError **error); gchar* bd_md_name_from_node (const gchar *node, GError **error); gchar* bd_md_get_status (const gchar *raid_spec, GError **error); gboolean bd_md_set_bitmap_location (const gchar *raid_spec, const gchar *location, GError **error); gchar* bd_md_get_bitmap_location (const gchar *raid_spec, GError **error); gboolean bd_md_request_sync_action (const gchar *raid_spec, const gchar *action, GError **error); #endif /* BD_MD */ module.h#include #ifndef BD_UTILS_MODULE #define BD_UTILS_MODULE GQuark bd_utils_module_error_quark (void); #define BD_UTILS_MODULE_ERROR bd_utils_module_error_quark () typedef enum { BD_UTILS_MODULE_ERROR_KMOD_INIT_FAIL, BD_UTILS_MODULE_ERROR_FAIL, BD_UTILS_MODULE_ERROR_NOEXIST, BD_UTILS_MODULE_ERROR_MODULE_CHECK_ERROR, BD_UTILS_MODULE_ERROR_INVALID_PLATFORM, } BDUtilsModuleError; typedef struct { guint major; guint minor; guint micro; } BDUtilsLinuxVersion; gboolean bd_utils_have_kernel_module (const gchar *module_name, GError **error); gboolean bd_utils_load_kernel_module (const gchar *module_name, const gchar *options, GError **error); gboolean bd_utils_unload_kernel_module (const gchar *module_name, GError **error); BDUtilsLinuxVersion * bd_utils_get_linux_version (GError **error); gint bd_utils_check_linux_version (guint major, guint minor, guint micro); #endif /* BD_UTILS_MODULE */ nvme.h#include #include #include #ifndef BD_NVME #define BD_NVME GQuark bd_nvme_error_quark (void); #define BD_NVME_ERROR bd_nvme_error_quark () /** * BDNVMEError: * @BD_NVME_ERROR_TECH_UNAVAIL: NVMe support not available. * @BD_NVME_ERROR_FAILED: General error. * @BD_NVME_ERROR_BUSY: The device is temporarily unavailable or in an inconsistent state. * @BD_NVME_ERROR_INVALID_ARGUMENT: Invalid argument. * @BD_NVME_ERROR_WOULD_FORMAT_ALL_NS: The NVMe controller indicates that it would format all namespaces in the NVM subsystem. * @BD_NVME_ERROR_SC_GENERIC: Generic NVMe Command Status Code. * @BD_NVME_ERROR_SC_CMD_SPECIFIC: NVMe Command Specific error. * @BD_NVME_ERROR_SC_MEDIA: Media and Data Integrity Errors: media specific errors that occur in the NVM or data integrity type errors. * @BD_NVME_ERROR_SC_PATH: Path related error. * @BD_NVME_ERROR_SC_VENDOR_SPECIFIC: NVMe Vendor specific error. * @BD_NVME_ERROR_NO_MATCH: No matching resource found (e.g. a Fabrics Controller). * @BD_NVME_ERROR_CONNECT: General connection error. * @BD_NVME_ERROR_CONNECT_ALREADY: Already connected. * @BD_NVME_ERROR_CONNECT_INVALID: Invalid argument specified. * @BD_NVME_ERROR_CONNECT_ADDRINUSE: HostNQN already in use. * @BD_NVME_ERROR_CONNECT_NODEV: Invalid interface. * @BD_NVME_ERROR_CONNECT_OPNOTSUPP: Operation not supported. * @BD_NVME_ERROR_CONNECT_REFUSED: Connection refused. */ typedef enum { BD_NVME_ERROR_TECH_UNAVAIL, BD_NVME_ERROR_FAILED, BD_NVME_ERROR_BUSY, BD_NVME_ERROR_INVALID_ARGUMENT, BD_NVME_ERROR_WOULD_FORMAT_ALL_NS, BD_NVME_ERROR_SC_GENERIC, BD_NVME_ERROR_SC_CMD_SPECIFIC, BD_NVME_ERROR_SC_MEDIA, BD_NVME_ERROR_SC_PATH, BD_NVME_ERROR_SC_VENDOR_SPECIFIC, BD_NVME_ERROR_NO_MATCH, BD_NVME_ERROR_CONNECT, BD_NVME_ERROR_CONNECT_ALREADY, BD_NVME_ERROR_CONNECT_INVALID, BD_NVME_ERROR_CONNECT_ADDRINUSE, BD_NVME_ERROR_CONNECT_NODEV, BD_NVME_ERROR_CONNECT_OPNOTSUPP, BD_NVME_ERROR_CONNECT_REFUSED, } BDNVMEError; typedef enum { BD_NVME_TECH_NVME = 0, BD_NVME_TECH_FABRICS, } BDNVMETech; typedef enum { BD_NVME_TECH_MODE_INFO = 1 << 0, BD_NVME_TECH_MODE_MANAGE = 1 << 1, BD_NVME_TECH_MODE_INITIATOR = 1 << 2, } BDNVMETechMode; /** * BDNVMEControllerFeature: * @BD_NVME_CTRL_FEAT_MULTIPORT: if set, then the NVM subsystem may contain more than one NVM subsystem port, otherwise it's single-port only. * @BD_NVME_CTRL_FEAT_MULTICTRL: if set, then the NVM subsystem may contain two or more controllers, otherwise contains only single controller. * @BD_NVME_CTRL_FEAT_SRIOV: if set, then the controller is associated with an SR-IOV Virtual Function, otherwise it's associated with a PCI Function or a Fabrics connection. * @BD_NVME_CTRL_FEAT_ANA_REPORTING: indicates that the NVM subsystem supports Asymmetric Namespace Access (ANA) Reporting. * @BD_NVME_CTRL_FEAT_FORMAT: indicates that the controller supports the Format NVM command. * @BD_NVME_CTRL_FEAT_FORMAT_ALL_NS: if set, then a format (excluding secure erase) of any namespace results in a format of all namespaces * in an NVM subsystem with all namespaces in an NVM subsystem configured with the same attributes. * If not set, then the controller supports format on a per namespace basis. * @BD_NVME_CTRL_FEAT_NS_MGMT: indicates that the controller supports the Namespace Management and Attachment capability. * @BD_NVME_CTRL_FEAT_SELFTEST: indicates that the controller supports the Device Self-test command. * @BD_NVME_CTRL_FEAT_SELFTEST_SINGLE: indicates that the NVM subsystem supports only one device self-test operation in progress at a time. * @BD_NVME_CTRL_FEAT_SANITIZE_CRYPTO: indicates that the controller supports the Crypto Erase sanitize operation. * @BD_NVME_CTRL_FEAT_SANITIZE_BLOCK: indicates that the controller supports the Block Erase sanitize operation. * @BD_NVME_CTRL_FEAT_SANITIZE_OVERWRITE: indicates that the controller supports the Overwrite sanitize operation. * @BD_NVME_CTRL_FEAT_SECURE_ERASE_ALL_NS: if set, then any secure erase performed as part of a format operation * results in a secure erase of all namespaces in the NVM subsystem. If not set, * then any secure erase performed as part of a format results in a secure erase * of the particular namespace specified. * @BD_NVME_CTRL_FEAT_SECURE_ERASE_CRYPTO: indicates that the cryptographic erase is supported. * @BD_NVME_CTRL_FEAT_STORAGE_DEVICE: indicates that the NVM subsystem is part of an NVMe Storage Device. * @BD_NVME_CTRL_FEAT_ENCLOSURE: indicates that the NVM subsystem is part of an NVMe Enclosure. * @BD_NVME_CTRL_FEAT_MGMT_PCIE: indicates that the NVM subsystem contains a Management Endpoint on a PCIe port. * @BD_NVME_CTRL_FEAT_MGMT_SMBUS: indicates that the NVM subsystem contains a Management Endpoint on an SMBus/I2C port. */ typedef enum { BD_NVME_CTRL_FEAT_MULTIPORT = 1 << 0, BD_NVME_CTRL_FEAT_MULTICTRL = 1 << 1, BD_NVME_CTRL_FEAT_SRIOV = 1 << 2, BD_NVME_CTRL_FEAT_ANA_REPORTING = 1 << 3, BD_NVME_CTRL_FEAT_FORMAT = 1 << 4, BD_NVME_CTRL_FEAT_FORMAT_ALL_NS = 1 << 5, BD_NVME_CTRL_FEAT_NS_MGMT = 1 << 6, BD_NVME_CTRL_FEAT_SELFTEST = 1 << 7, BD_NVME_CTRL_FEAT_SELFTEST_SINGLE = 1 << 8, BD_NVME_CTRL_FEAT_SANITIZE_CRYPTO = 1 << 9, BD_NVME_CTRL_FEAT_SANITIZE_BLOCK = 1 << 10, BD_NVME_CTRL_FEAT_SANITIZE_OVERWRITE = 1 << 11, BD_NVME_CTRL_FEAT_SECURE_ERASE_ALL_NS = 1 << 12, BD_NVME_CTRL_FEAT_SECURE_ERASE_CRYPTO = 1 << 13, BD_NVME_CTRL_FEAT_STORAGE_DEVICE = 1 << 14, BD_NVME_CTRL_FEAT_ENCLOSURE = 1 << 15, BD_NVME_CTRL_FEAT_MGMT_PCIE = 1 << 16, BD_NVME_CTRL_FEAT_MGMT_SMBUS = 1 << 17, } BDNVMEControllerFeature; /** * BDNVMEControllerType: * @BD_NVME_CTRL_TYPE_UNKNOWN: Controller type not reported (as reported by older NVMe-compliant devices). * @BD_NVME_CTRL_TYPE_IO: I/O controller. * @BD_NVME_CTRL_TYPE_DISCOVERY: Discovery controller. * @BD_NVME_CTRL_TYPE_ADMIN: Administrative controller. */ typedef enum { BD_NVME_CTRL_TYPE_UNKNOWN = 0, BD_NVME_CTRL_TYPE_IO, BD_NVME_CTRL_TYPE_DISCOVERY, BD_NVME_CTRL_TYPE_ADMIN, } BDNVMEControllerType; /** * BDNVMEControllerInfo: * @pci_vendor_id: The PCI Vendor ID. * @pci_subsys_vendor_id: The PCI Subsystem Vendor ID. * @ctrl_id: Controller ID, the NVM subsystem unique controller identifier associated with the controller. * @fguid: FRU GUID, a 128-bit value that is globally unique for a given Field Replaceable Unit. * @model_number: The model number. * @serial_number: The serial number. * @firmware_ver: The currently active firmware revision. * @nvme_ver: The NVM Express base specification that the controller implementation supports or %NULL when not reported by the device. * @features: features and capabilities present for this controller, see #BDNVMEControllerFeature. * @controller_type: The controller type. * @selftest_ext_time: Extended Device Self-test Time, if #BD_NVME_CTRL_FEAT_SELFTEST is supported then this field * indicates the nominal amount of time in one minute units that the controller takes * to complete an extended device self-test operation when in power state 0. * @hmb_pref_size: Host Memory Buffer Preferred Size indicates the preferred size that the host * is requested to allocate for the Host Memory Buffer feature in bytes. * @hmb_min_size: Host Memory Buffer Minimum Size indicates the minimum size that the host * is requested to allocate for the Host Memory Buffer feature in bytes. * @size_total: Total NVM Capacity in the NVM subsystem in bytes. * @size_unalloc: Unallocated NVM Capacity in the NVM subsystem in bytes. * @num_namespaces: Maximum Number of Allowed Namespaces supported by the NVM subsystem. * @subsysnqn: NVM Subsystem NVMe Qualified Name, UTF-8 null terminated string. */ typedef struct BDNVMEControllerInfo { guint16 pci_vendor_id; guint16 pci_subsys_vendor_id; guint16 ctrl_id; gchar *fguid; gchar *model_number; gchar *serial_number; gchar *firmware_ver; gchar *nvme_ver; guint64 features; BDNVMEControllerType controller_type; gint selftest_ext_time; guint64 hmb_pref_size; guint64 hmb_min_size; guint64 size_total; guint64 size_unalloc; guint num_namespaces; gchar *subsysnqn; } BDNVMEControllerInfo; /** * BDNVMELBAFormatRelativePerformance: * Performance index of the LBA format relative to other LBA formats supported by the controller. * @BD_NVME_LBA_FORMAT_RELATIVE_PERFORMANCE_UNKNOWN: Unknown relative performance index. * @BD_NVME_LBA_FORMAT_RELATIVE_PERFORMANCE_BEST: Best performance. * @BD_NVME_LBA_FORMAT_RELATIVE_PERFORMANCE_BETTER: Better performance. * @BD_NVME_LBA_FORMAT_RELATIVE_PERFORMANCE_GOOD: Good performance. * @BD_NVME_LBA_FORMAT_RELATIVE_PERFORMANCE_DEGRADED: Degraded performance. */ typedef enum { BD_NVME_LBA_FORMAT_RELATIVE_PERFORMANCE_UNKNOWN = 0, BD_NVME_LBA_FORMAT_RELATIVE_PERFORMANCE_BEST = 1, BD_NVME_LBA_FORMAT_RELATIVE_PERFORMANCE_BETTER = 2, BD_NVME_LBA_FORMAT_RELATIVE_PERFORMANCE_GOOD = 3, BD_NVME_LBA_FORMAT_RELATIVE_PERFORMANCE_DEGRADED = 4 } BDNVMELBAFormatRelativePerformance; /** * BDNVMELBAFormat: * Namespace LBA Format Data Structure. * @data_size: LBA data size (i.e. a sector size) in bytes. * @metadata_size: metadata size in bytes or `0` in case of no metadata support. * @relative_performance: Relative Performance index, see #BDNVMELBAFormatRelativePerformance. */ typedef struct BDNVMELBAFormat { guint16 data_size; guint16 metadata_size; BDNVMELBAFormatRelativePerformance relative_performance; } BDNVMELBAFormat; /** * BDNVMENamespaceFeature: * @BD_NVME_NS_FEAT_THIN: indicates that the namespace supports thin provisioning. Specifically, the Namespace Capacity * reported may be less than the Namespace Size. * @BD_NVME_NS_FEAT_MULTIPATH_SHARED: indicates the capability to attach the namespace to two or more controllers * in the NVM subsystem concurrently. * @BD_NVME_NS_FEAT_FORMAT_PROGRESS: indicates the capability to report the percentage of the namespace * that remains to be formatted. * @BD_NVME_NS_FEAT_ROTATIONAL: indicates a rotational medium. */ typedef enum { BD_NVME_NS_FEAT_THIN = 1 << 0, BD_NVME_NS_FEAT_MULTIPATH_SHARED = 1 << 1, BD_NVME_NS_FEAT_FORMAT_PROGRESS = 1 << 2, BD_NVME_NS_FEAT_ROTATIONAL = 1 << 3, } BDNVMENamespaceFeature; /** * BDNVMENamespaceInfo: * @nsid: The Namespace Identifier (NSID). * @eui64: IEEE Extended Unique Identifier: a 64-bit IEEE Extended Unique Identifier (EUI-64) * that is globally unique and assigned to the namespace when the namespace is created. * Remains fixed throughout the life of the namespace and is preserved across namespace * and controller operations. * @nguid: Namespace Globally Unique Identifier: a 128-bit value that is globally unique and * assigned to the namespace when the namespace is created. Remains fixed throughout * the life of the namespace and is preserved across namespace and controller operations. * @uuid: Namespace 128-bit Universally Unique Identifier (UUID) as specified in RFC 4122. * @nsize: Namespace Size: total size of the namespace in logical blocks. The number of logical blocks * is based on the formatted LBA size (see @current_lba_format). * @ncap: Namespace Capacity: maximum number of logical blocks that may be allocated in the namespace * at any point in time. The number of logical blocks is based on the formatted LBA size (see @current_lba_format). * @nuse: Namespace Utilization: current number of logical blocks allocated in the namespace. * This field is smaller than or equal to the Namespace Capacity. The number of logical * blocks is based on the formatted LBA size (see @current_lba_format). * @features: features and capabilities present for this namespace, see #BDNVMENamespaceFeature. * @format_progress_remaining: The percentage value remaining of a format operation in progress. * @write_protected: %TRUE if the namespace is currently write protected and all write access to the namespace shall fail. * @lba_formats: (array zero-terminated=1): A list of supported LBA Formats. * @current_lba_format: A LBA Format currently used for the namespace. Contains zeroes in case of * an invalid or no supported LBA Format reported. */ typedef struct BDNVMENamespaceInfo { guint32 nsid; gchar *eui64; gchar *uuid; gchar *nguid; guint64 nsize; guint64 ncap; guint64 nuse; guint64 features; guint8 format_progress_remaining; gboolean write_protected; BDNVMELBAFormat **lba_formats; BDNVMELBAFormat current_lba_format; } BDNVMENamespaceInfo; /** * BDNVMESmartCriticalWarning: * @BD_NVME_SMART_CRITICAL_WARNING_SPARE: the available spare capacity has fallen below the threshold. * @BD_NVME_SMART_CRITICAL_WARNING_TEMPERATURE: a temperature is either greater than or equal to an over temperature threshold; * or less than or equal to an under temperature threshold. * @BD_NVME_SMART_CRITICAL_WARNING_DEGRADED: the NVM subsystem reliability has been degraded due to significant media * related errors or any internal error that degrades NVM subsystem reliability. * @BD_NVME_SMART_CRITICAL_WARNING_READONLY: all of the media has been placed in read only mode. Unrelated to the write * protection state of a namespace. * @BD_NVME_SMART_CRITICAL_WARNING_VOLATILE_MEM: the volatile memory backup device has failed. Valid only if the controller * has a volatile memory backup solution. * @BD_NVME_SMART_CRITICAL_WARNING_PMR_READONLY: Persistent Memory Region has become read-only or unreliable. */ typedef enum { BD_NVME_SMART_CRITICAL_WARNING_SPARE = 1 << 0, BD_NVME_SMART_CRITICAL_WARNING_TEMPERATURE = 1 << 1, BD_NVME_SMART_CRITICAL_WARNING_DEGRADED = 1 << 2, BD_NVME_SMART_CRITICAL_WARNING_READONLY = 1 << 3, BD_NVME_SMART_CRITICAL_WARNING_VOLATILE_MEM = 1 << 4, BD_NVME_SMART_CRITICAL_WARNING_PMR_READONLY = 1 << 5, } BDNVMESmartCriticalWarning; /** * BDNVMESmartLog: * @critical_warning: critical warnings for the state of the controller, see #BDNVMESmartCriticalWarning. * @avail_spare: Available Spare: a normalized percentage (0% to 100%) of the remaining spare capacity available. * @spare_thresh: Available Spare Threshold: a normalized percentage (0% to 100%) of the available spare threshold. * @percent_used: Percentage Used: a vendor specific estimate of the percentage drive life used based on the * actual usage and the manufacturer's prediction. A value of 100 indicates that the estimated * endurance has been consumed, but may not indicate an NVM subsystem failure. * The value is allowed to exceed 100. * @total_data_read: An estimated calculation of total data read in bytes based on calculation of data * units read from the host. A value of 0 indicates that the number of Data Units Read * is not reported. * @total_data_written: An estimated calculation of total data written in bytes based on calculation * of data units written by the host. A value of 0 indicates that the number * of Data Units Written is not reported. * @ctrl_busy_time: Amount of time the controller is busy with I/O commands, reported in minutes. * @power_cycles: The number of power cycles. * @power_on_hours: The number of power-on hours, excluding a non-operational power state. * @unsafe_shutdowns: The number of unsafe shutdowns as a result of a Shutdown Notification not received prior to loss of power. * @media_errors: Media and Data Integrity Errors: the number of occurrences where the controller detected * an unrecovered data integrity error (e.g. uncorrectable ECC, CRC checksum failure, or LBA tag mismatch). * @num_err_log_entries: Number of Error Information Log Entries: the number of Error Information log * entries over the life of the controller. * @temperature: Composite Temperature: temperature in Kelvins that represents the current composite * temperature of the controller and associated namespaces or 0 when not applicable. * @temp_sensors: Temperature Sensor 1-8: array of the current temperature reported by temperature sensors * 1-8 in Kelvins or 0 when the particular sensor is not available. * @wctemp: Warning Composite Temperature Threshold (WCTEMP): indicates the minimum Composite Temperature (@temperature) * value that indicates an overheating condition during which controller operation continues. * A value of 0 indicates that no warning temperature threshold value is reported by the controller. * @cctemp: Critical Composite Temperature Threshold (CCTEMP): indicates the minimum Composite Temperature (@temperature) * value that indicates a critical overheating condition (e.g., may prevent continued normal operation, * possibility of data loss, automatic device shutdown, extreme performance throttling, or permanent damage). * A value of 0 indicates that no critical temperature threshold value is reported by the controller. * @warning_temp_time: Warning Composite Temperature Time: the amount of time in minutes that the Composite Temperature (@temperature) * is greater than or equal to the Warning Composite Temperature Threshold (@wctemp) and less than the * Critical Composite Temperature Threshold (@cctemp). * @critical_temp_time: Critical Composite Temperature Time: the amount of time in minutes that the Composite Temperature (@temperature) * is greater than or equal to the Critical Composite Temperature Threshold (@cctemp). */ typedef struct BDNVMESmartLog { guint critical_warning; guint8 avail_spare; guint8 spare_thresh; guint8 percent_used; guint64 total_data_read; guint64 total_data_written; guint64 ctrl_busy_time; guint64 power_cycles; guint64 power_on_hours; guint64 unsafe_shutdowns; guint64 media_errors; guint64 num_err_log_entries; guint16 temperature; guint16 temp_sensors[8]; guint16 wctemp; guint16 cctemp; guint warning_temp_time; guint critical_temp_time; } BDNVMESmartLog; /** * BDNVMETransportType: * Transport Type. * @BD_NVME_TRANSPORT_TYPE_UNSPECIFIED: Not indicated * @BD_NVME_TRANSPORT_TYPE_RDMA: RDMA Transport * @BD_NVME_TRANSPORT_TYPE_FC: Fibre Channel Transport * @BD_NVME_TRANSPORT_TYPE_TCP: TCP Transport * @BD_NVME_TRANSPORT_TYPE_LOOP: Intra-host Transport (loopback) */ typedef enum { BD_NVME_TRANSPORT_TYPE_UNSPECIFIED = 0, BD_NVME_TRANSPORT_TYPE_RDMA = 1, BD_NVME_TRANSPORT_TYPE_FC = 2, BD_NVME_TRANSPORT_TYPE_TCP = 3, BD_NVME_TRANSPORT_TYPE_LOOP = 254 } BDNVMETransportType; /** * BDNVMEErrorLogEntry: * @error_count: internal error counter, a unique identifier for the error. * @command_id: the Command Identifier of the command that the error is associated with or `0xffff` if the error is not specific to a particular command. * @command_specific: Command Specific Information specific to @command_id. * @command_status: the Status code for the command that completed. * @command_error: translated command error in the BD_NVME_ERROR domain or %NULL in case @command_status indicates success. * @lba: the first LBA that experienced the error condition. * @nsid: the NSID of the namespace that the error is associated with. * @transport_type: type of the transport associated with the error. */ typedef struct BDNVMEErrorLogEntry { guint64 error_count; guint16 command_id; guint64 command_specific; guint16 command_status; GError *command_error; guint64 lba; guint32 nsid; BDNVMETransportType transport_type; } BDNVMEErrorLogEntry; /** * BDNVMESelfTestAction: * Action taken by the Device Self-test command. * @BD_NVME_SELF_TEST_ACTION_NOT_RUNNING: No device self-test operation in progress. Not a valid argument for bd_nvme_device_self_test(). * @BD_NVME_SELF_TEST_ACTION_SHORT: Start a short device self-test operation. * @BD_NVME_SELF_TEST_ACTION_EXTENDED: Start an extended device self-test operation. * @BD_NVME_SELF_TEST_ACTION_VENDOR_SPECIFIC: Start a vendor specific device self-test operation. * @BD_NVME_SELF_TEST_ACTION_ABORT: Abort the device self-test operation. Only valid for bd_nvme_device_self_test(). */ typedef enum { BD_NVME_SELF_TEST_ACTION_NOT_RUNNING = 0, BD_NVME_SELF_TEST_ACTION_SHORT = 1, BD_NVME_SELF_TEST_ACTION_EXTENDED = 2, BD_NVME_SELF_TEST_ACTION_VENDOR_SPECIFIC = 3, BD_NVME_SELF_TEST_ACTION_ABORT = 4, } BDNVMESelfTestAction; /** * BDNVMESelfTestResult: * @BD_NVME_SELF_TEST_RESULT_NO_ERROR: Operation completed without error. * @BD_NVME_SELF_TEST_RESULT_ABORTED: Operation was aborted by a Device Self-test command. * @BD_NVME_SELF_TEST_RESULT_CTRL_RESET: Operation was aborted by a Controller Level Reset. * @BD_NVME_SELF_TEST_RESULT_NS_REMOVED: Operation was aborted due to a removal of a namespace from the namespace inventory. * @BD_NVME_SELF_TEST_RESULT_ABORTED_FORMAT: Operation was aborted due to the processing of a Format NVM command. * @BD_NVME_SELF_TEST_RESULT_FATAL_ERROR: A fatal error or unknown test error occurred while the controller was executing the device self-test operation and the operation did not complete. * @BD_NVME_SELF_TEST_RESULT_UNKNOWN_SEG_FAIL: Operation completed with a segment that failed and the segment that failed is not known. * @BD_NVME_SELF_TEST_RESULT_KNOWN_SEG_FAIL: Operation completed with one or more failed segments and the first segment that failed is indicated in the Segment Number field. * @BD_NVME_SELF_TEST_RESULT_ABORTED_UNKNOWN: Operation was aborted for unknown reason. * @BD_NVME_SELF_TEST_RESULT_ABORTED_SANITIZE: Operation was aborted due to a sanitize operation. */ typedef enum { BD_NVME_SELF_TEST_RESULT_NO_ERROR = 0, BD_NVME_SELF_TEST_RESULT_ABORTED = 1, BD_NVME_SELF_TEST_RESULT_CTRL_RESET = 2, BD_NVME_SELF_TEST_RESULT_NS_REMOVED = 3, BD_NVME_SELF_TEST_RESULT_ABORTED_FORMAT = 4, BD_NVME_SELF_TEST_RESULT_FATAL_ERROR = 5, BD_NVME_SELF_TEST_RESULT_UNKNOWN_SEG_FAIL = 6, BD_NVME_SELF_TEST_RESULT_KNOWN_SEG_FAIL = 7, BD_NVME_SELF_TEST_RESULT_ABORTED_UNKNOWN = 8, BD_NVME_SELF_TEST_RESULT_ABORTED_SANITIZE = 9, } BDNVMESelfTestResult; /** * BDNVMESelfTestLogEntry: * @result: Result of the device self-test operation. * @action: The Self-test Code value (action) that was specified in the Device Self-test command that started this device self-test operation. * @segment: Segment number where the first self-test failure occurred. Valid only when @result is set to #BD_NVME_SELF_TEST_RESULT_KNOWN_SEG_FAIL. * @power_on_hours: Number of power-on hours at the time the device self-test operation was completed or aborted. Does not include time that the controller was powered and in a low power state condition. * @nsid: Namespace ID that the Failing LBA occurred on. * @failing_lba: LBA of the logical block that caused the test to fail. If the device encountered more than one failed logical block during the test, then this field only indicates one of those failed logical blocks. * @status_code_error: Translated NVMe Command Status Code representing additional information related to errors or conditions. */ typedef struct BDNVMESelfTestLogEntry { BDNVMESelfTestResult result; BDNVMESelfTestAction action; guint8 segment; guint64 power_on_hours; guint32 nsid; guint64 failing_lba; GError *status_code_error; } BDNVMESelfTestLogEntry; /** * BDNVMESelfTestLog: * @current_operation: Current running device self-test operation. There's no corresponding record in @entries for a device self-test operation that is in progress. * @current_operation_completion: Percentage of the currently running device self-test operation. Only valid when @current_operation is other than #BD_NVME_SELF_TEST_ACTION_NOT_RUNNING. * @entries: (array zero-terminated=1): Self-test log entries for the last 20 operations, sorted from newest (first element) to oldest. */ typedef struct BDNVMESelfTestLog { BDNVMESelfTestAction current_operation; guint8 current_operation_completion; BDNVMESelfTestLogEntry **entries; } BDNVMESelfTestLog; /** * BDNVMEFormatSecureErase: * Optional Format NVM secure erase action. * @BD_NVME_FORMAT_SECURE_ERASE_NONE: No secure erase operation requested. * @BD_NVME_FORMAT_SECURE_ERASE_USER_DATA: User Data Erase: All user data shall be erased, contents of the user data after the erase is indeterminate * (e.g., the user data may be zero filled, one filled, etc.). If a User Data Erase is requested and all affected * user data is encrypted, then the controller is allowed to use a cryptographic erase to perform the requested User Data Erase. * @BD_NVME_FORMAT_SECURE_ERASE_CRYPTO: Cryptographic Erase: All user data shall be erased cryptographically. This is accomplished by deleting the encryption key. */ typedef enum { BD_NVME_FORMAT_SECURE_ERASE_NONE = 0, BD_NVME_FORMAT_SECURE_ERASE_USER_DATA = 1, BD_NVME_FORMAT_SECURE_ERASE_CRYPTO = 2, } BDNVMEFormatSecureErase; /** * BDNVMESanitizeStatus: * @BD_NVME_SANITIZE_STATUS_NEVER_SANITIZED: The NVM subsystem has never been sanitized. * @BD_NVME_SANITIZE_STATUS_IN_PROGRESS: A sanitize operation is currently in progress. * @BD_NVME_SANITIZE_STATUS_IN_PROGESS: Deprecated alias for %BD_NVME_SANITIZE_STATUS_IN_PROGRESS * @BD_NVME_SANITIZE_STATUS_SUCCESS: The most recent sanitize operation completed successfully including any additional media modification. * @BD_NVME_SANITIZE_STATUS_SUCCESS_NO_DEALLOC: The most recent sanitize operation for which No-Deallocate After Sanitize was requested has completed successfully with deallocation of all user data. * @BD_NVME_SANITIZE_STATUS_FAILED: The most recent sanitize operation failed. */ typedef enum { BD_NVME_SANITIZE_STATUS_NEVER_SANITIZED = 0, BD_NVME_SANITIZE_STATUS_IN_PROGRESS = 1, BD_NVME_SANITIZE_STATUS_IN_PROGESS = BD_NVME_SANITIZE_STATUS_IN_PROGRESS, BD_NVME_SANITIZE_STATUS_SUCCESS = 2, BD_NVME_SANITIZE_STATUS_SUCCESS_NO_DEALLOC = 3, BD_NVME_SANITIZE_STATUS_FAILED = 4, } BDNVMESanitizeStatus; /** * BDNVMESanitizeLog: * @sanitize_progress: The percentage complete of the sanitize operation. * @sanitize_status: The status of the most recent sanitize operation. * @global_data_erased: Indicates that no user data has been written either since the drive was manufactured and * has never been sanitized or since the most recent successful sanitize operation. * @overwrite_passes: Number of completed passes if the most recent sanitize operation was an Overwrite. * @time_for_overwrite: Estimated time in seconds needed to complete an Overwrite sanitize operation with 16 passes in the background. * A value of -1 means that no time estimate is reported. A value of 0 means that the operation is expected * to be completed in the background when the Sanitize command is completed. * @time_for_block_erase: Estimated time in seconds needed to complete a Block Erase sanitize operation in the background. * A value of -1 means that no time estimate is reported. A value of 0 means that the operation is expected * to be completed in the background when the Sanitize command is completed. * @time_for_crypto_erase: Estimated time in seconds needed to complete a Crypto Erase sanitize operation in the background. * A value of -1 means that no time estimate is reported. A value of 0 means that the operation is expected * to be completed in the background when the Sanitize command is completed. * @time_for_overwrite_nd: Estimated time in seconds needed to complete an Overwrite sanitize operation and the associated * additional media modification in the background when the No-Deallocate After Sanitize or * the No-Deallocate Modifies Media After Sanitize features have been requested. * @time_for_block_erase_nd: Estimated time in seconds needed to complete a Block Erase sanitize operation and the associated * additional media modification in the background when the No-Deallocate After Sanitize or * the No-Deallocate Modifies Media After Sanitize features have been requested. * @time_for_crypto_erase_nd: Estimated time in seconds needed to complete a Crypto Erase sanitize operation and the associated * additional media modification in the background when the No-Deallocate After Sanitize or * the No-Deallocate Modifies Media After Sanitize features have been requested. */ typedef struct BDNVMESanitizeLog { gdouble sanitize_progress; BDNVMESanitizeStatus sanitize_status; gboolean global_data_erased; guint8 overwrite_passes; gint64 time_for_overwrite; gint64 time_for_block_erase; gint64 time_for_crypto_erase; gint64 time_for_overwrite_nd; gint64 time_for_block_erase_nd; gint64 time_for_crypto_erase_nd; } BDNVMESanitizeLog; /** * BDNVMESanitizeAction: * @BD_NVME_SANITIZE_ACTION_EXIT_FAILURE: Exit Failure Mode. * @BD_NVME_SANITIZE_ACTION_BLOCK_ERASE: Start a Block Erase sanitize operation - a low-level block erase method that is specific to the media. * @BD_NVME_SANITIZE_ACTION_OVERWRITE: Start an Overwrite sanitize operation - writing a fixed data pattern or related patterns in multiple passes. * @BD_NVME_SANITIZE_ACTION_CRYPTO_ERASE: Start a Crypto Erase sanitize operation - changing the media encryption keys for all locations on the media. */ typedef enum { BD_NVME_SANITIZE_ACTION_EXIT_FAILURE = 0, BD_NVME_SANITIZE_ACTION_BLOCK_ERASE = 1, BD_NVME_SANITIZE_ACTION_OVERWRITE = 2, BD_NVME_SANITIZE_ACTION_CRYPTO_ERASE = 3, } BDNVMESanitizeAction; void bd_nvme_controller_info_free (BDNVMEControllerInfo *info); BDNVMEControllerInfo * bd_nvme_controller_info_copy (BDNVMEControllerInfo *info); void bd_nvme_lba_format_free (BDNVMELBAFormat *fmt); BDNVMELBAFormat * bd_nvme_lba_format_copy (BDNVMELBAFormat *fmt); void bd_nvme_namespace_info_free (BDNVMENamespaceInfo *info); BDNVMENamespaceInfo * bd_nvme_namespace_info_copy (BDNVMENamespaceInfo *info); void bd_nvme_smart_log_free (BDNVMESmartLog *log); BDNVMESmartLog * bd_nvme_smart_log_copy (BDNVMESmartLog *log); void bd_nvme_error_log_entry_free (BDNVMEErrorLogEntry *entry); BDNVMEErrorLogEntry * bd_nvme_error_log_entry_copy (BDNVMEErrorLogEntry *entry); void bd_nvme_self_test_log_entry_free (BDNVMESelfTestLogEntry *entry); BDNVMESelfTestLogEntry * bd_nvme_self_test_log_entry_copy (BDNVMESelfTestLogEntry *entry); const gchar * bd_nvme_self_test_result_to_string (BDNVMESelfTestResult result, GError **error); void bd_nvme_self_test_log_free (BDNVMESelfTestLog *log); BDNVMESelfTestLog * bd_nvme_self_test_log_copy (BDNVMESelfTestLog *log); void bd_nvme_sanitize_log_free (BDNVMESanitizeLog *log); BDNVMESanitizeLog * bd_nvme_sanitize_log_copy (BDNVMESanitizeLog *log); /* * If using the plugin as a standalone library, the following functions should * be called to: * * init() - initialize the plugin, returning TRUE on success * close() - clean after the plugin at the end or if no longer used * */ gboolean bd_nvme_init (void); void bd_nvme_close (void); gboolean bd_nvme_is_tech_avail (BDNVMETech tech, guint64 mode, GError **error); BDNVMEControllerInfo * bd_nvme_get_controller_info (const gchar *device, GError **error); BDNVMENamespaceInfo * bd_nvme_get_namespace_info (const gchar *device, GError **error); BDNVMESmartLog * bd_nvme_get_smart_log (const gchar *device, GError **error); BDNVMEErrorLogEntry ** bd_nvme_get_error_log_entries (const gchar *device, GError **error); BDNVMESelfTestLog * bd_nvme_get_self_test_log (const gchar *device, GError **error); BDNVMESanitizeLog * bd_nvme_get_sanitize_log (const gchar *device, GError **error); gboolean bd_nvme_device_self_test (const gchar *device, BDNVMESelfTestAction action, GError **error); gboolean bd_nvme_format (const gchar *device, guint16 lba_data_size, guint16 metadata_size, BDNVMEFormatSecureErase secure_erase, GError **error); gboolean bd_nvme_sanitize (const gchar *device, BDNVMESanitizeAction action, gboolean no_dealloc, gint overwrite_pass_count, guint32 overwrite_pattern, gboolean overwrite_invert_pattern, GError **error); gchar * bd_nvme_get_host_nqn (GError **error); gchar * bd_nvme_generate_host_nqn (GError **error); gchar * bd_nvme_get_host_id (GError **error); gboolean bd_nvme_set_host_nqn (const gchar *host_nqn, GError **error); gboolean bd_nvme_set_host_id (const gchar *host_id, GError **error); gboolean bd_nvme_connect (const gchar *subsysnqn, const gchar *transport, const gchar *transport_addr, const gchar *transport_svcid, const gchar *host_traddr, const gchar *host_iface, const gchar *host_nqn, const gchar *host_id, const BDExtraArg **extra, GError **error); gboolean bd_nvme_disconnect (const gchar *subsysnqn, GError **error); gboolean bd_nvme_disconnect_by_path (const gchar *path, GError **error); gchar ** bd_nvme_find_ctrls_for_ns (const gchar *ns_sysfs_path, const gchar *subsysnqn, const gchar *host_nqn, const gchar *host_id, GError **error); gchar ** bd_nvme_find_namespaces_for_ctrl (const gchar *ctrl_sysfs_path, const gchar *subsysnqn, const gchar *host_nqn, const gchar *host_id, GError **error); #endif /* BD_NVME */ part.h#include #ifndef BD_PART #define BD_PART GQuark bd_part_error_quark (void); #define BD_PART_ERROR bd_part_error_quark () typedef enum { BD_PART_ERROR_TECH_UNAVAIL, BD_PART_ERROR_FAIL, BD_PART_ERROR_INVAL, BD_PART_ERROR_EXISTS, } BDPartError; typedef enum { BD_PART_TABLE_MSDOS, BD_PART_TABLE_GPT, BD_PART_TABLE_UNDEF, } BDPartTableType; typedef enum { BD_PART_TYPE_NORMAL = 0x00, BD_PART_TYPE_LOGICAL = 0x01, BD_PART_TYPE_EXTENDED = 0x02, BD_PART_TYPE_FREESPACE = 0x04, BD_PART_TYPE_METADATA = 0x08, BD_PART_TYPE_PROTECTED = 0x10 } BDPartType; typedef enum { BD_PART_TYPE_REQ_NORMAL = 0x00, BD_PART_TYPE_REQ_LOGICAL = 0x01, BD_PART_TYPE_REQ_EXTENDED = 0x02, BD_PART_TYPE_REQ_NEXT = 0x04 } BDPartTypeReq; typedef enum { BD_PART_ALIGN_NONE, BD_PART_ALIGN_MINIMAL, BD_PART_ALIGN_OPTIMAL, } BDPartAlign; typedef struct BDPartSpec { gchar *path; gchar *name; gchar *uuid; gchar *id; gchar *type_guid; guint64 type; guint64 start; guint64 size; gboolean bootable; guint64 attrs; gchar *type_name; } BDPartSpec; BDPartSpec* bd_part_spec_copy (BDPartSpec *data); void bd_part_spec_free (BDPartSpec *data); typedef struct BDPartDiskSpec { gchar *path; BDPartTableType table_type; guint64 size; guint64 sector_size; } BDPartDiskSpec; BDPartDiskSpec* bd_part_disk_spec_copy (BDPartDiskSpec *data); void bd_part_disk_spec_free (BDPartDiskSpec *data); typedef enum { BD_PART_TECH_MBR = 0, BD_PART_TECH_GPT, } BDPartTech; typedef enum { BD_PART_TECH_MODE_CREATE_TABLE = 1 << 0, BD_PART_TECH_MODE_MODIFY_TABLE = 1 << 1, BD_PART_TECH_MODE_QUERY_TABLE = 1 << 2, BD_PART_TECH_MODE_MODIFY_PART = 1 << 3, BD_PART_TECH_MODE_QUERY_PART = 1 << 4, } BDPartTechMode; /* * If using the plugin as a standalone library, the following functions should * be called to: * * init() - initialize the plugin, returning TRUE on success * close() - clean after the plugin at the end or if no longer used * */ gboolean bd_part_init (void); void bd_part_close (void); gboolean bd_part_is_tech_avail (BDPartTech tech, guint64 mode, GError **error); gboolean bd_part_create_table (const gchar *disk, BDPartTableType type, gboolean ignore_existing, GError **error); BDPartSpec* bd_part_get_part_spec (const gchar *disk, const gchar *part, GError **error); BDPartSpec* bd_part_get_part_by_pos (const gchar *disk, guint64 position, GError **error); BDPartDiskSpec* bd_part_get_disk_spec (const gchar *disk, GError **error); BDPartSpec** bd_part_get_disk_parts (const gchar *disk, GError **error); BDPartSpec** bd_part_get_disk_free_regions (const gchar *disk, GError **error); BDPartSpec* bd_part_get_best_free_region (const gchar *disk, BDPartType type, guint64 size, GError **error); BDPartSpec* bd_part_create_part (const gchar *disk, BDPartTypeReq type, guint64 start, guint64 size, BDPartAlign align, GError **error); gboolean bd_part_delete_part (const gchar *disk, const gchar *part, GError **error); gboolean bd_part_resize_part (const gchar *disk, const gchar *part, guint64 size, BDPartAlign align, GError **error); gboolean bd_part_set_part_name (const gchar *disk, const gchar *part, const gchar *name, GError **error); gboolean bd_part_set_part_type (const gchar *disk, const gchar *part, const gchar *type_guid, GError **error); gboolean bd_part_set_part_id (const gchar *disk, const gchar *part, const gchar *part_id, GError **error); gboolean bd_part_set_part_bootable (const gchar *disk, const gchar *part, gboolean bootable, GError **error); gboolean bd_part_set_part_attributes (const gchar *disk, const gchar *part, guint64 attrs, GError **error); gboolean bd_part_set_part_uuid (const gchar *disk, const gchar *part, const gchar *uuid, GError **error); const gchar* bd_part_get_part_table_type_str (BDPartTableType type, GError **error); const gchar* bd_part_get_type_str (BDPartType type, GError **error); #endif /* BD_PART */ plugins.h{#include #include #ifndef BD_PLUGINS #define BD_PLUGINS typedef enum { BD_PLUGIN_LVM = 0, BD_PLUGIN_BTRFS, BD_PLUGIN_SWAP, BD_PLUGIN_LOOP, BD_PLUGIN_CRYPTO, BD_PLUGIN_MPATH, BD_PLUGIN_DM, BD_PLUGIN_MDRAID, BD_PLUGIN_S390, BD_PLUGIN_PART, BD_PLUGIN_FS, BD_PLUGIN_NVDIMM, BD_PLUGIN_NVME, BD_PLUGIN_SMART, BD_PLUGIN_UNDEF } BDPlugin; #define BD_TYPE_PLUGIN_SPEC (bd_plugin_spec_get_type ()) GType bd_plugin_spec_get_type(void); /** * BDPluginSpec: * @name: %BDPlugin name, e.g. %BD_PLUGIN_LVM * @so_name: (nullable): SO name of the plugin to load or %NULL for default * */ typedef struct BDPluginSpec { BDPlugin name; const gchar *so_name; } BDPluginSpec; BDPluginSpec* bd_plugin_spec_copy (BDPluginSpec *spec); void bd_plugin_spec_free (BDPluginSpec *spec); BDPluginSpec* bd_plugin_spec_new (BDPlugin name, const gchar *so_name); gboolean bd_is_plugin_available (BDPlugin plugin); gchar** bd_get_available_plugin_names (void); gchar* bd_get_plugin_soname (BDPlugin plugin); gchar* bd_get_plugin_name (BDPlugin plugin); #endif /* BD_PLUGINS */ sizes.h#include #ifndef BD_UTILS_SIZES #define BD_UTILS_SIZES #define KIBIBYTE *1024ULL #define MEBIBYTE *1024ULL KIBIBYTE #define GIBIBYTE *1024ULL MEBIBYTE #define TEBIBYTE *1024ULL GIBIBYTE #define PEBIBYTE *1024ULL TEBIBYTE #define EXBIBYTE *1024ULL PEBIBYTE #define KiB KIBIBYTE #define MiB MEBIBYTE #define GiB GIBIBYTE #define TiB TEBIBYTE #define PiB PEBIBYTE #define EiB EXBIBYTE #define KILOBYTE *1000ULL #define MEGABYTE *1000ULL KILOBYTE #define GIGABYTE *1000ULL MEGABYTE #define TERABYTE *1000ULL GIGABYTE #define PETABYTE *1000ULL TERABYTE #define EXABYTE *1000ULL PETABYTE #define KB KILOBYTE #define MB MEGABYTE #define GB GIGABYTE #define TB TERABYTE #define PB PETABYTE #define EB EXABYTE #endif /* BD_UTILS_SIZES */ swap.hc#include #include #ifndef BD_SWAP #define BD_SWAP GQuark bd_swap_error_quark (void); #define BD_SWAP_ERROR bd_swap_error_quark () typedef enum { BD_SWAP_ERROR_TECH_UNAVAIL, BD_SWAP_ERROR_UNKNOWN_STATE, BD_SWAP_ERROR_ACTIVATE, BD_SWAP_ERROR_ACTIVATE_OLD, BD_SWAP_ERROR_ACTIVATE_SUSPEND, BD_SWAP_ERROR_ACTIVATE_UNKNOWN, BD_SWAP_ERROR_ACTIVATE_PAGESIZE, BD_SWAP_ERROR_LABEL_INVALID, BD_SWAP_ERROR_UUID_INVALID, } BDSwapError; typedef enum { BD_SWAP_TECH_SWAP = 0, } BDSwapTech; typedef enum { BD_SWAP_TECH_MODE_CREATE = 1 << 0, BD_SWAP_TECH_MODE_ACTIVATE_DEACTIVATE = 1 << 1, BD_SWAP_TECH_MODE_QUERY = 1 << 2, BD_SWAP_TECH_MODE_SET_LABEL = 1 << 3, BD_SWAP_TECH_MODE_SET_UUID = 1 << 4, } BDSwapTechMode; /* * If using the plugin as a standalone library, the following functions should * be called to: * * init() - initialize the plugin, returning TRUE on success * close() - clean after the plugin at the end or if no longer used * */ gboolean bd_swap_init (void); void bd_swap_close (void); gboolean bd_swap_is_tech_avail (BDSwapTech tech, guint64 mode, GError **error); gboolean bd_swap_mkswap (const gchar *device, const gchar *label, const gchar *uuid, const BDExtraArg **extra, GError **error); gboolean bd_swap_swapon (const gchar *device, gint priority, GError **error); gboolean bd_swap_swapoff (const gchar *device, GError **error); gboolean bd_swap_swapstatus (const gchar *device, GError **error); gboolean bd_swap_set_label (const gchar *device, const gchar *label, GError **error); gboolean bd_swap_check_label (const gchar *label, GError **error); gboolean bd_swap_set_uuid (const gchar *device, const gchar *uuid, GError **error); gboolean bd_swap_check_uuid (const gchar *uuid, GError **error); #endif /* BD_SWAP */ utils.hr#ifndef BD_UTILS #define BD_UTILS #include "sizes.h" #include "exec.h" #include "extra_arg.h" #include "dev_utils.h" #include "module.h" #include "dbus.h" #include "logging.h" /** * SECTION: utils * @short_description: library providing utility functions used by the blockdev library and its plugins * @title: Utils * @include: utils.h */ #endif /* BD_UTILS */ liblibbd_crypto.solibbd_crypto.so.3.0.0libbd_crypto.so.3libbd_crypto.so.3.0.0libbd_crypto.so.3.0.0(ELF>@!@8 @@@@]]]mmX))00RtdXPtdPPPQtd "& Xd?I`p}Dp&H[t #.?FMSd}1q| Eu n    7 i        - <         L ` m {    <A pm 0o= wW p~ `8  g  H  * x0 py= z  `*O PEi ta HQ  s  ! P  j  *[ 9 W [   po 0qe1 s$ }G        `v }1  `  H " PwJ     *> `n x16    rP tr Ѕ    ge B~ P-m `  kR  0 q P*+   0E  a z3   @  H p  0s vW p  `[  90P`0A4A7AA A   j@(@1H@"@` Bh P`( X0`x`I@D@@L "@L H0jkrw|~TP\`u2pSp}{`7T^^ۜ4yvD߶N)^o&@U`+?sCߙqoy#:u[ *kLc8$u j9 R̹7U oduvǐ$d$F;NT1buXKp'd.3T=awzj[/h/,qs:Ρ  T|X>3g^@ZP 7r~`Ru࠭{(b8tuw)%0-=__register_frame_info__cxa_finalize__deregister_frame_infobd_crypto_luks_pbkdf_copyg_malloc0_ng_strdupbd_crypto_luks_pbkdf_freeg_freebd_crypto_luks_pbkdf_newbd_crypto_luks_extra_copybd_crypto_luks_extra_freebd_crypto_luks_extra_newbd_crypto_integrity_extra_newbd_crypto_integrity_extra_copybd_crypto_integrity_extra_freebd_crypto_luks_info_freebd_crypto_luks_info_copybd_crypto_bitlk_info_freebd_crypto_bitlk_info_copybd_crypto_integrity_info_freebd_crypto_integrity_info_copybd_crypto_luks_token_info_freebd_crypto_luks_token_info_copybd_crypto_initnewlocalecrypt_set_log_callbackg_strdup_printfbd_utils_logbd_utils_log_formatbd_crypto_closefreelocalecrypt_set_debug_levelbd_crypto_is_tech_availbd_crypto_error_quarkg_set_error_literalg_quark_from_static_stringbd_crypto_generate_backup_passphraseg_random_int_rangebd_crypto_device_is_luksblkid_new_probeopeng_set_errorblkid_free_probeblkid_probe_set_deviceg_usleepcloseblkid_probe_enable_partitionsblkid_probe_set_partitions_flagsblkid_probe_enable_superblocksblkid_probe_set_superblocks_flagsblkid_do_safeprobeblkid_probe_lookup_valueg_strcmp0bd_crypto_luks_statuscrypt_init_by_namestrerror_lcrypt_statuscrypt_freebd_crypto_keyslot_context_freeexplicit_bzerobd_crypto_keyslot_context_copymemcpybd_crypto_keyslot_context_new_passphrasebd_crypto_keyslot_context_new_keyfilebd_crypto_keyslot_context_new_keyringbd_crypto_keyslot_context_new_volume_keybd_utils_report_startedbd_utils_report_finishedg_propagate_errorcrypt_initg_strsplitg_strv_lengthg_strfreevg_str_has_prefixstrlenmemcmpioctl__errno_locationbd_utils_report_progresssleepcrypt_get_pbkdf_defaultcrypt_set_pbkdf_typeg_propagate_prefixed_errormemsetcrypt_formatcrypt_format_luks2_opalcrypt_keyslot_add_by_volume_keycrypt_keyfile_device_readcrypt_safe_freebd_crypto_luks_formatbd_crypto_luks_open_flagscrypt_loadcrypt_activate_by_passphrasecrypt_activate_by_keyringstrchrbd_crypto_luks_openbd_crypto_luks_closecrypt_deactivatebd_crypto_luks_add_keycrypt_keyslot_add_by_passphrasebd_crypto_luks_remove_keycrypt_keyslot_destroybd_crypto_luks_change_keycrypt_keyslot_change_by_passphrasebd_crypto_luks_resizecrypt_get_active_devicecrypt_resizecrypt_get_typebd_crypto_luks_suspendcrypt_suspendbd_crypto_luks_resumecrypt_resume_by_passphrasebd_crypto_luks_kill_slotbd_crypto_luks_header_backupcrypt_header_backupbd_crypto_luks_header_restorecrypt_header_restorebd_crypto_luks_check_labelbd_crypto_luks_set_labelcrypt_set_labelbd_crypto_luks_set_uuidcrypt_set_uuidbd_crypto_luks_convertcrypt_convertbd_crypto_luks_set_persistent_flagscrypt_persistent_flags_setbd_crypto_luks_infocrypt_get_ciphercrypt_get_cipher_modecrypt_get_uuidcrypt_get_device_namecrypt_get_sector_sizecrypt_get_data_offsetcrypt_get_hw_encryption_typeblkid_do_probeblkid_probe_has_valuebd_crypto_bitlk_infobd_crypto_integrity_infocrypt_get_integrity_infobd_crypto_luks_token_infog_ptr_array_newcrypt_token_maxcrypt_token_statuscrypt_keyslot_maxcrypt_token_is_assignedg_ptr_array_addg_ptr_array_freebd_crypto_integrity_formatg_path_get_basenameg_random_intcrypt_get_dircrypt_activate_by_volume_keycrypt_wipebd_crypto_integrity_openbd_crypto_integrity_closebd_crypto_keyring_add_keyadd_keybd_crypto_device_seems_encryptedreadbd_crypto_tc_open_flagsbd_crypto_tc_openbd_crypto_tc_closebd_crypto_escrow_devicebd_crypto_bitlk_open_flagsbd_crypto_bitlk_openbd_crypto_bitlk_closebd_crypto_fvault2_open_flagsbd_crypto_fvault2_openbd_crypto_fvault2_closebd_crypto_opal_is_supportedbd_crypto_opal_wipe_devicecrypt_wipe_hw_opalbd_crypto_opal_formatbd_crypto_opal_reset_deviceg_prefix_errorfsynclibcryptsetup.so.12CRYPTSETUP_2.0CRYPTSETUP_2.4CRYPTSETUP_2.7libblkid.so.1BLKID_2.15BLKID_2.17libkeyutils.so.1KEYUTILS_0.3/shikumi/software/libunwind-23.1.2/nl9vpy8avhsg510jyqsp7mngdf0cvacp/lib:/shikumi/software/libblockdev-3.5.0/n17f2yb80anjn5nz6kbs7f5s2a73hcq2/lib:/shikumi/software/libblockdev-3.5.0/n17f2yb80anjn5nz6kbs7f5s2a73hcq2/lib:/shikumi/software/glib-2.90.1/s1r26wiyyq6d9dnqwb0d5yxx5cfs86d3/lib:/shikumi/software/libffi-3.8.0/p4xxidfd2xmdyajjx98qf7xs06h4wwmk/lib:/shikumi/software/pcre2-10.48/5f3v7r6qn0jn05mhmgd0dl7jx0dp9w1l/lib:/shikumi/software/zlib-1.3.2/5rvydc8zdy6067388cjkzydinly5nicq/lib:/shikumi/software/eudev-3.2.15/2giknpra4g70yyr2msz1nk44sggwpk6z/lib:/shikumi/software/kmod-34.2/89mg5s3x7n8f9mj1wid78dr37asw83xj/lib:/shikumi/software/zstd-1.5.7/imf8r1im3989yx5gfi06i5zd7ncinv5f/lib:/shikumi/software/xz-5.8.4/d74kkdcxq6jyp7r17fz5bp7sancrvz6k/lib:/shikumi/software/libcryptsetup-2.8.8/8b18wf5pfnglmlqng8vlg65s3ipdcl98/lib:/shikumi/software/openssl-3.5.8/8ig1bny7byn08mkiaiv2llgz3kv7c6w0/lib:/shikumi/software/json-c-0.19/s0py3fk5a4wbn74x8rjwn5sr6yrs00nv/lib:/shikumi/software/lvm2-2.03.44/ni1q51l5x3v8fb82xmnzdl5qsi2ga94x/lib:/shikumi/software/util-linux-2.42.4/r1vq57hd5ksv8b3yfnlcc3ld73fwygf8/lib:/shikumi/software/keyutils-1.6.3/z7cnlf1v2vwjk9m0jcxssgcznysb019x/lib:/shikumi/software/e2fsprogs-1.47.4/73jppb8qd844cygwx6nzlg4b802nxclp/lib:/shikumi/software/libbytesize-2.12/hbm2rm2bfysbphbk0n1zll1fwsndi84s/lib:/shikumi/software/gmp-6.3.0/gq115ij73y2racpik0xhhnwh6i3dfdsq/lib:/shikumi/software/mpfr-4.2.2/hm7psb9gjq1j3mf263yqxy46nwnn6mk4/lib:/shikumi/software/libnvme-1.16.2/2wa4n4i30prrk7f6ghxlq1p4w9g01drx/lib:/shikumi/software/keyutils-1.6.3/z7cnlf1v2vwjk9m0jcxssgcznysb019x/lib:/shikumi/software/libbytesize-2.12/hbm2rm2bfysbphbk0n1zll1fwsndi84s/liblibbd_utils.so.3libudev.so.1libkmod.so.2libgio-2.0.so.0libgobject-2.0.so.0libglib-2.0.so.0libc.solibbd_crypto.so.3mn)))**** *(*k0*8*@*H*P* X* `* h* p* x*t****************++++ +!(+"0+#8+$@+%H+&P+'X+(`+)h+*p++x+,+-+.+/+0+1+2+3+4+5+6+7+8+9+:+;+,<,=,>,? ,@(,A0,B8,C@,DH,EP,FX,G`,Hh,Ip,Jx,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,[-\-]-^-_ -`(-a0-b8-c@-dH-eP-fX-`-zh-p-x-g-h-iCQCCCDkDDEJJJJ 0C0E0C0EY@?I@C@CCCOnly 'create', 'open', 'query', 'add-key', 'remove-key', 'resize', 'suspend-resume', 'backup-restore', 'modify' supported for LUKSOnly 'open' supported for TrueCryptEscrow technology is not available, libblockdev has been compiled without escrow support.Only 'create', 'open' and 'query' supported for IntegrityOnly 'open' and 'query' supported for BITLKOnly 'add key' supported for kernel keyringOnly 'open' supported for FVAULT2Only 'create', 'query' and 'modify' supported for OPALUnknown technologyg-bd-crypto-error-quark0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz./Failed to create a new probeFailed to open the device '%s'Failed to create a probe for the device '%s'Failed to probe the device '%s'USAGEFailed to get usage for the device '%s'cryptoTYPEFailed to get filesystem type for the device '%s'crypto_LUKSFailed to initialize device: %sinvalidinactiveactivebusyUnknown device's stateNo passphrase specified.No volume key specified.Started formatting '%s' as LUKS deviceLUKS1LUKS2Unknown or unsupported LUKS version specifiedaes-xts-plain64-Invalid cipher specification: '%s'xts-/dev/randomFailed to get random data entropy level: %sWaiting for enough random data entropyFailed to check random data entropy levelOnly 'passphrase' context type is valid for OPAL format.Invalid extra arguments specified. Only `data_alignment`and `data_device` are valid for LUKS 1.pbkdf2Invalid pbkdf specified. Only `pbkdf2` is valid for LUKS 1.Failed to get PBKDF parameters for '%s'.Failed to format device: %sFormat createdFailed to add passphrase: %sAdded keyFailed to read key from file '%s': %sFailed to add key file: %sOnly 'passphrase' and 'key file' context types are valid for LUKS format.CompletedStarted opening '%s' LUKS deviceFailed to load device's parameters: %sOnly 'passphrase', 'key file' and 'keyring' context types are valid for LUKS open.Failed to activate device: Incorrect passphrase.Failed to activate device: Unknown or unsupported LUKS2 requirements detected.Failed to activate device: %sLUKSStarted adding key to the LUKS device '%s'Failed to load key from file '%s': %sOnly 'passphrase' and 'key file' context types are valid for LUKS add key.Failed to add key: %sStarted removing key from the LUKS device '%s'Only 'passphrase' and 'key file' context types are valid for LUKS remove key.Failed to determine key slot: %sFailed to remove key: %sStarted changing key on the LUKS device '%s'Only 'passphrase' and 'key file' context types are valid for LUKS change key.Failed to change the passphrase: No keyslot with given passphrase found.Failed to change the passphrase: %sStarted resizing LUKS device '%s'Failed to get information about '%s': %sOnly 'passphrase' and 'key file' context types are valid for LUKS resize.Insufficient permissions to resize device. You need to specify passphrase or keyfile to resize LUKS 2 devices that don't have verified key loaded in kernel.Failed to resize device: %sStarted suspending LUKS device '%s'Failed to suspend device: %sStarted resuming '%s' LUKS deviceOnly 'passphrase' and 'key file' context types are valid for LUKS resume.Failed to resume device: %sStarted killing slot %d on LUKS device '%s'Failed to destroy keyslot: %sStarted header backup of LUKS device '%s'Failed to backup LUKS header: %sStarted LUKS header restore on device '%s'Failed to restore LUKS header: %sLabel for LUKS must be at most 47 characters longSubsystem for LUKS must be at most 47 characters longFailed to load device: %sLabel can be set only on LUKS 2 devices.Failed to set label: %sFailed to set UUID: %sIt is possible to convert only between LUKS1 and LUKS2 formats. Device %s is of type: %sConversion to the %s type was requested, but device %s is already of type: %sConversion failed: %sPersistent flags can be set only on LUKS v2Failed to set flags: %sUnknown or unsupported LUKS versionFailed to get HW encryption type: %sUnknown HW encryption type: %dBITLKINTEGRITYFailed to get information about device: %sStarted formatting '%s' as integrity deviceOnly 'volume key' context type is valid for integrity format.bd-temp-integrity-%s-%d%s/%sFailed to activate the newly created integrity device for wiping: %sStarting to wipe the newly created integrity deviceWipe finishedFailed to wipe the newly created integrity device: %sFailed to deactivate temporary device %sStarted opening '%s' integrity deviceOnly 'volume key' context type is valid for integrity open.integrityuserFailed to add key to kernel keyring: %sStarted determining if device '%s' seems to be encryptedFailed to open deviceFailed to read deviceStarted opening '%s' TrueCrypt/VeraCrypt deviceOnly 'passphrase' context type is valid for TC open.No passphrase nor key file specified, cannot open.TCRYPTTrueCrypt/VeraCryptStarted opening '%s' BITLK deviceOnly 'passphrase' and 'key file' context types are valid for BITLK open.Started opening '%s' FVAULT2 deviceFVAULT2Only 'passphrase' and 'key file' context types are valid for FVAULT2 open.Failed to get opal status for the device '%s': %sStarted wiping '%s' LUKS HW-OPAL deviceDevice %s isn't a LUKS HW-OPAL device.Only 'passphrase' context type is valid for OPAL wipe.Failed to wipe LUKS HW-OPAL device: %sEither hardware and software encryption or hardware encryption only must be selected for OPAL formatCipher cannot be specified for hardware encryption only OPAL devicesOPAL doesn't seem to be supported on %sStarted PSID reset on '%s' LUKS HW-OPAL deviceOPAL doesn't seem to be supported on %s: Only 'passphrase' and 'key file' context types are valid for OPAL PSID reset.[cryptsetup] %sUnknown cryptsetup log level %d.Failed to get default values for pbkdf.'max_memory_kb' is not valid option for 'pbkdf2', ignoring.Device name can be at most 127 characters long.Device name cannot contain '/' character.Started closing %s device '%s'Failed to deactivate device: %sLABELFailed to get label for the device '%s'SUBSYSTEMFailed to get subsystem for the device '%s'Integrity device wipe in progress;R Ll4\Tl t !l"#L##4<%T%t&&'(((4)T*t,,-12|34 5T5t\667FHHEHMHEHH(H}HHEHH0HEHĀ]ffff.UHH0HE}HuUMLELMؿ(HEЋMHEЉHMHEHHMHEЉHMHEЉHHEHEЉHHE؉HEЉHHEHEЉH HEH0]fUHH H}H}u HE}(4HEHEHEHEHHHEHHHEHHEHHEHHEHHEHHEHHEHHEHHEH HEH HEHEHEH ]fff.UHHH}H}u H}ŒH]fff.UHHH}H}uWHEHx莌HEHx职HEHxtHEHx gHEHx8ZHEHx@MH}DH]fffff.UHHH}H}u HE1P΋HEHEHEHEH@HEH}蹋HEHMHEHHHEH@HEH}蔋HEHMHEHHHEH@HEH}oHEHMHEHHHEH@ HEH}JHEHMHEHH HEH(HEH(HEHH0HEHH0HEH@8HEH}HEHMHEHH8HEH@@HEH}HEHMHEHH@HEHHHEHHHEHEHEHĀ]ffffff.UHHH}H}uH}uIH Z~HEH}HuE̋EHEHwHHMHGHc HH.HESH)HEFH%HE9HHE,HEHEHE~H}ƺH ~H}EHEHEHEHP]UHHH}H}uHE8u$HEHxHEHp HEHx|aHE8uHEHx|GHE8uHEHx|-HE8u"HEHxHEHp~HEHx|H}|H]ff.UHH@H}H}u HE[ !|HEHEЋHEȉHEЃ8uOHEHx{HHEHHHEHxHEHpHEHP~HEHHHEHHHEЃ8uJHEH@HEH}{HEHMHEHHHEHHHEHHHEHHHEHHHEЃ8u'HEH@HEH}X{HEHMHEHHUHEЃ8uJHEHx{HHEHHHEHxHEHpHEHP3}HEHHHEHHHEHEHEH@]ff.UHH0H}HuHUHEH}tH}u.HEHEY{H}Љƺ H RR{HE_ YzHEHEH}=zHHEHHHEHxHuHU]|HMHEHHHEHEHEH0]ffffff.UHH@H}HuHUHMHE yHEHEHEHEH}yHEHMHEHHHMHEHHHMHEHHHEH@]UHH0H}HuHE IyHEHEHEHEH}:yHEHMHEHHHEH0]UHH0H}HuHUHEH}tH}u.HEHEyH}Љƺ H yHE_ xHEHEH}xHHEHHHEHxHuHUzHMHEHHHEHEHEH0]ffffff.UHHHE(HE EHEH}HuHUHMLEDMHEHEEEHEHEHEHEHEHDžxHDžpHkHXHeH`H_Hh}wt }ww$THuH=^wHEH}yHEH}`w}u HWHEa}u HJHELwHx1H 3wH}HxHp:yH}(Hx:yE HuH}/yE}toqwp1+}H5ߣxpIHxH wH}HxHpxH}(HxxE& }t }H}t HEHhHzHhHhHEH}H5ksxHEH}vxtgvLEHxH 3vH}wH}JxH}HxHpwH}(HxwEY H}uHEH@HHHH@Dž<HHuHHH5w<HHHH4$HHwH0HDž(H0r@HHHH4$HHH5Dww$<<$$u#HEHxH5wt HEHE/tHETtHEHHEHEHHEH} H=1 uE}}RHUvtdv8H5udIHxH >t}tH}uH}vH}HxHpuH}(HxuE( EH;EH}1H&v,v}RHUus`u8H5't`IHxH js}tH}tH}EuH}HxHptH}(HxtET )}sa!sHxH CsH}NtH}tH}HxHpqtH}(HxqtETHE 8u HE H@HXHE H@H`arHxH Ԯ~rH}HxHpsH}(HxsH}sH}tEKTt#H=utHH}HntH}}"HEHxu HExuHEHx u HEHx(taqHxH >qH}rH}msH}HxHp sH}(Hx sE|HEHx0 HEH@0H8H56Grta-qHxH #qH}ZrH}rH}HxHp}rH}(Hx}rEHEHx0HxHpHpuYHxtOH}qH}prH}HxHp rH}(HxHMHrErH}HprH1rHEHHHEH@HH}HuHEHHEHHLU1AHML$HD${rEHp,o}H1@:rHEHx0HxHHuYHxtOH}pH}IqH}HxHppH}(HxHMH|qEKHHHEH@HHDžHEHHHEH@HHExtHE@\ 1\\HEH@ HHEH@(HTt@H}HEH0HEHPLM1ALHXLL$HD$qE;H}HuHEHHEHHLU1AHML$HD$pEHjmTtfHx1@wpH=J;pHxH}HEH0HEHPLM1ALxHXLL$HD$IpE9H}HuHEHHEHHHEE1EMH$HD$oEH}0o}txEmX1+}H5^nXIHxH xkmH}RnH}HxHp~nH}(Hx~nEH}2HDnHE؃8H}HEL@HELH1HKoE}}x}lT1+}H5mTIHxH ۩lH}mH}HxHpmH}(HxmE)H}dH5nHE؃8H}HEHpHEL@HELHHUHM1$nE}kDHEH@HH1+}H5lDLHIHxH kH}lH}HxHplH}(HxlE5H}LELM1HmEH}m}}xj@1+}H5Pk@IHxH kH}kH}HxHplH}(HxlEH}dH lUSjHxH 7IjH}HxHpkH}(HxkH}\kE"H}HkH}H50xkEEH]DUHH0H}HuHEHEH}u HEH=kHEH}u1HEHExiH}ЉƺH DqiHEx(uhHEHEH HE؉H HEH8tHEHHEHHEHHEHHEHxtHEHHHEHHHEHHHEHHHExtHEHHE؉HHEHHE؉HHExtHEHHE؉HHE@ HEHHE؉HHEH8H5oiu5HExtH5[hHE@HE@RHExtHEHHE؉HHEHHE؉HHExtHEHHE؉HHEHHE؉HHEHEHEH0]fUHHPHEHEH}HuHUHMLEDMH}HuHUHMLEDMLUHEE1L$D$HD$HD$VHP]UHHH}HuHUMLEHEHEHEEHEHEHEEH}Huu EHuH=(tfHEH}GhHEH}fHuH}]hE}t`fE1+}H5guIH}H ,fH}HEHpgH}HugE3H}1H4iE}ti&fE1+}H5BguIH}H jUfH}HE8H}HEHpHEL@HELHHUHM1$`E}<]lHEH@Hp1+}H5F^lLpIH}H O]H}6^HE8u H}_H}HEHpS^H}HuV^EYHE8uHEH@HEHEH@HEa}\H}H Gv\HE8u H}4_H}HEHp]H}Hu]H}}]EH}HUHMLELMQ_EHE8u H}^HE8u H}^H}!]}}c[h1+}H54\hIH}H [H}HEHp]H}Hu]EH}H5\EEHĠ]DUHHH}HuHUHEEHEHEHEHEHEHuH=$ZHEH}S\HEH}&ZHuH}i\Eԃ}t`ZE1+}H5[uIH}H 8ZH}HEHp[H}Hu[EH}1H@]Eԃ}ti2ZE1+}H5N[uIH}H vaZH}H[H}HEHpw[H}Huz[E}HE8u-H}HEHHHEL@1ƺE1\E=HE8H}HEHpHEL@HELHHUHM1$)\Eԃ}tyKYEHEH@HE1+}H5[ZuLEIH}H ɖjYH}QZH}HEHpZH}HuZEH}HMLE1ƺE1[EH}[OXH}H XH}HEHpZH}HuZH}YE }}iPXE1+}H5lYuIH} H XH}fYH}HEHpYH}HuYEH}؋u@[Eԃ}tfWE1+}H5CXuIH}H XH}XH}HEHpYH}HuYE H}XH}H5XEEHĀ]DUHHH}HuHUHMHEHEHEHEHEEHEHEHEHuH=ǗlVHEH}?XHEH}VHuH}UXE}t`VE1+}H5WuIH}H $VH}HEHpWH}HuWE)H}1H,YE}tiVE1+}H5:WuIH}H bMVH}4WH}HEHpcWH}HufWEHE8H}HEHpHEL@HELHHUHM1$KXE}tmU|HEH@HE1+}H5ρzV|LEIH}H UH}mVH}HEHpVH}HuVEtHE8uHEH@HEHEH@HEOTH}H ؕTH}HEHp1VH}Hu4VH}UElHE8H}HEHpHEL@HELHHUHM1$WE},TlHEH@Hp1+}H56UlLpIH}H ?TH}&UHE8u H}VH}HEHpCUH}HuFUEHE8uHEH@HEHEH@HEamSH}H |fSHE8u H}$VH}HEHpTH}HuTH}mTEH}HMLELMHEH$[VEHE8u H}UHE8u H}UH} T}}uRH}H RCE1+}H5oZDuIH}H }mCH}HEHpDH}HuDEH}HU1FEԃ}tfBE1+}H55oCuIH}H MBH}CH}HEHp DH}Hu DE H}CH}H5CEEHP]f.UHH0H}HuHUH}tE1+}H5k?H}uIH >H}?EH}?EEH`]DUHHH}uHUHEEHuH}?Eă}tJHEHE=E1+}H5ij?H}uIH x'>EH}1H@Eă}tSHEHE=E1+}H5j>H}uIH =H}>EjH}@HEH}H5xB>tXH}H5x->tCHEHE =H}LELMкH J=H}1>EUH5xH (xHDHEH}Hu=uHHEHE<H}LELMHEкH H$<H}=EzH}Hu1^@Eă}tPHEHE8<E1+}H5hT=H}uIH dg<H}N=EH}<=EEHĀ]fUHHpH}uHUHEEEHuH}J=Eԃ}tJHEHE;E1+}H5g<H}uIH v;EH}1H7>Eԃ}tSHEHE!;E1+}H5g=<H}uIH 4P;H}7<EcH}r>HH52v;t9HEHE:H}ƺH :H};E Et EЃEЋEt EЃ@EЋEt E EЋEt E EЋEt E EЋE t E EЋE@t E EH}؋U1>Eԃ}tPHEHE9E1+}H5NH|HEH}65HEHMHxHH8H|HEH}5HEHMHxHH@H}C:ll}=Hx@H1+lH5b6H¿H5H|,5lHtHt/Ht0Hx@HGHx@H7Hx@H'lH5{4Hx@HH})6HxHEHEH]ÐUHHH}HuHUHxHDžpDžlDžhHDž`4HpHpu?HxHXO4HXLEH (n4EH}c4lluKHxHP3HPLEH m14Hp54EtHpl1H 4hhtVHxHH~3HHLEH Wm3Hp3l1EHp3Hp7hhtVHxH@2H@LEH m<3Hp@3lU1EtHpH5V7hhu(HdyHEH}1HEHMHEHHpH51HEHuH}0E@H}H5v12E}t!H}0HEHuH}0E}tTHEHE/E1+}H5[0H}uIH j/H}0HE([.HEH}N3HEH}Q.HEHMHEHH}93HEH},.HEHMHEHHH}#3HEH}.HEHMHEHHH} 3HEH}-HEHMHEHHH}2E}~EE1EMHEH H}/HEHEHEHĀ]UHHH}HuHEHP1`0HDžHHuH}/DDt&H}2/HEHuH}.DjH}1H0DDtIH}H5t10DDt$H}.HEHuH}.DDtcHEH8B-@1+DH5YX.H8@IH ge-H}L.HElH}HP1DDtcHEH(,41+DH5+Y-H(4IH s,H}-HE0+HHHpHEH}+HEHMHHHxHHHhHHH dHHH`HHHHPHHHHHEHEH}+HEHMHHHH HEHEH}*HEHMHHHH(H},HHHEHEH]fDUHHpH}HuHEHEHEHEHuH},E}t#H}q,HEHuH},,EH}H8HpjH}H8jE H}H}H5Z8EEH]DUHHH}HuH}HUH5e茺H]fDUHH@H}HuHUHMHuHUHMH=ceA!Eԃ}}IHEHEE<8H5H.H}ȋuIH eAEEEH@]UHHPH}HuEH1#WRHDžHDžHDžHuH=dHHHHH}1bE}uRHH dHHHpcH}HcE}HC H=tZHH +dHHHpH}H}E*}DžH=s0DžsRH*(\\YX^HH5W1 P.vP.$EEHP]ff.UHHHE(E EEH}HuHUHMDEDMHEEHEHEHh1H.HDž`HDžPDžLH}Hu(qu EHuH=bHEH}HEH}H}t;Dž\HE؋\H<t\\܋\H`H}tXHE8tOHPH aH}HPHp?H}(HP?E H}uYH`uO}HP H asH}HPHpH}(HPEHuH}Eă}toH1+}H5C1HIHPH Q>H}HPHpZH}(HPZE;H}tHEH@H@ 1H@H@HhH}tHEH@H8 1H8H8HpHEHxH`E}t EE}t EE}t EE}t }tEEH}H5E`HhEă}tx41+}H5AB4IHPH TH}H}HPHp H}(HP EE tLLE tLLH}HuDL1HEă}}u01+}H5qA0IHPH 8T)H}H}HPHp<H}(HP<E H}H}H5R EEH]UHAVSHPHE(E EEH}HuHUHMDEDMH}HuHUHMDEDMȋ]D]Du E1ҸADEHE($D\$DT$HD$HP[A^]fUHHH}HuH}HUH5^̱H]fDUHH0H}HuHUHMLELMHUп]H0]UHHH}HuHUMLEHEEHEHEHEHEHEEH}Huu EHuH=N]tHEH}GHEH}HuH}]Eă}t`E1+}H5?uIH}H ,MH}HEHpH}HuEH}H5RY10Eă}ti"E1+}H5>>uIH}H fPQH}8H}HEHpgH}HujE]E܃t EEE܃t EEHE8u.H}HuHEHHHEL@DMwEDHE8H}HEHpHEL@HELHHUHM1$Eă}t|HEH@HE1+}H5t=|LEIH}H N+H}H}HEHpAH}HuDE7H}HuHMLEDMEH}NOgH}H Z`H}HEHpH}HuH}yE}}uH}H N<x1+}H5V<xIH}H OH}H}HEHp'H}Hu*E H}H}H5MEEHĐ]DUHH0H}HuHUMLEH}HuHUDE1ɸAELEH0]UHHH}HuH}HUH5UH]fDUHHH}HuHUMLEHEEHEHEHEHEHEEH}Hugu EHuH=)Y HEH}HEH} HuH}Eă}t`E1+}H5:+uIH}H H>H}HEHp]H}Hu`EH}H5X1Eă}ti E1+}H5:uIH}H K H}H}HEHpH}HuE]E܃t EEE܃t EEHE8u.H}HuHEHHHEL@DMEDHE8H}HEHpHEL@HELHHUHM1$`Eă}t |HEH@HE1+}H58 |LEIH}H I H} H}HEHp H}Hu E7H}HuHMLEDMEH}O H}H V H}HEHp? H}HuB H} E}}uv H}H LJo H}HEHp'H}Hu*EHE8uHEH@HEHEH@HEHE8H}HEHpHEL@HELHHUHM1$Eă}ty EHEH@HE1+}H5p/uLEIH}H @*H}H}HEHp@H}HuCE OH}H OH}HEHpH}HuH}EH}HUHMоE1EHE8u H}}tf E1+}H5|.'uIH}H M:H}!H}HEHpPH}HuSE H}H}H5?!EEHĀ]fffff.UHH}E}fE}tEEH]PXPX5)%)@%)h%)h%)h%)h%)h%z)h%r)h%j)hp%b)h`%Z)h P%R)h @%J)h 0%B)h %:)h %2)h%*)h%")h%)h%)h% )h%)h%(h%(h%(hp%(h`%(hP%(h@%(h0%(h %(h%(h%(h%(h %(h!%(h"%(h#%(h$%z(h%%r(h&%j(h'p%b(h(`%Z(h)P%R(h*@%J(h+0%B(h, %:(h-%2(h.%*(h/%"(h0%(h1%(h2% (h3%(h4%'h5%'h6%'h7p%'h8`%'h9P%'h:@%'h;0%'h< %'h=%'h>%'h?%'h@%'hA%'hB%'hC%'hD%z'hE%r'hF%j'hGp%b'hH`%Z'hIP%R'hJ@%J'hK0%B'hL %:'hM%2'hN%*'hO%"'hP%'hQ%'hR% 'hS%'hT%&hU%&hV%&hWp%&hX`%&hYP%&hZ@%&h[0%&h\ %&h]%&h^%&h_%&h`%&ha%&hb%&hc%&hd%z&he%r&hf%j&hgp%b&hh`%Z&hiP%R&hj@%J&hk0%B&hl %:&hm%2&hn%*&ho%"&hp%&hq%&hr, oX- )8  o , /oo4oVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfv&6FVfvclang version 23.1.2clang version 23.1.2clang version 23.1.2Linker: LLD 23.1.2  m8-. `S@-@S nJ]-szb)- y  `   :  & P;( `S1 ,7 / = S"o  `n 0o= po p   0qe$ q= r[ 0sz s$ tr ta vW `v PwJ w; x1Z xy py= z3  z# }9Mh } p~ /Po P- 2A @`g Ѕ  ` 1J\gr (/<Tt p [   H+  P*@ Q   h      9   ` # 0 ?  pV d  z           0-  F V  kn }  g   a      + A W m     0     j  0 C U m }   `       *3 MU v{ `  * 9  H `* 3 HJ *b "~ P PE B.dynsym.gnu.version.gnu.version_r.gnu.hash.dynstr.rela.dyn.rela.plt.rodata.eh_frame_hdr.eh_frame.text.init.fini.plt.init_array.fini_array.dynamic.got.relro_padding.data.got.plt.bss.comment.symtab.shstrtab.strtabcrtbegin.c__do_init__do_init.__initialized__EH_FRAME_LIST____do_init.__object__do_fini__do_fini.__finalized__init__finicrypto.cc_localecrypto_log_redirectget_pbkdf_params_is_dm_name_valid_crypto_closeget_subsystem_labelsynced_close_wipe_progressg_autoptr_cleanup_generic_gfreecrtend.c_init_fini__register_frame_info__cxa_finalize__dso_handle__deregister_frame_infobd_crypto_luks_pbkdf_copyg_malloc0_ng_strdupbd_crypto_luks_pbkdf_freeg_freebd_crypto_luks_pbkdf_newbd_crypto_luks_extra_copybd_crypto_luks_extra_freebd_crypto_luks_extra_newbd_crypto_integrity_extra_newbd_crypto_integrity_extra_copybd_crypto_integrity_extra_freebd_crypto_luks_info_freebd_crypto_luks_info_copybd_crypto_bitlk_info_freebd_crypto_bitlk_info_copybd_crypto_integrity_info_freebd_crypto_integrity_info_copybd_crypto_luks_token_info_freebd_crypto_luks_token_info_copybd_crypto_initnewlocalecrypt_set_log_callbackg_strdup_printfbd_utils_logbd_utils_log_formatbd_crypto_closefreelocalecrypt_set_debug_levelbd_crypto_is_tech_availbd_crypto_error_quarkg_set_error_literalg_quark_from_static_stringbd_crypto_generate_backup_passphraseg_random_int_rangebd_crypto_device_is_luksblkid_new_probeopeng_set_errorblkid_free_probeblkid_probe_set_deviceg_usleepcloseblkid_probe_enable_partitionsblkid_probe_set_partitions_flagsblkid_probe_enable_superblocksblkid_probe_set_superblocks_flagsblkid_do_safeprobeblkid_probe_lookup_valueg_strcmp0bd_crypto_luks_statuscrypt_init_by_namestrerror_lcrypt_statuscrypt_freebd_crypto_keyslot_context_freeexplicit_bzerobd_crypto_keyslot_context_copymemcpybd_crypto_keyslot_context_new_passphrasebd_crypto_keyslot_context_new_keyfilebd_crypto_keyslot_context_new_keyringbd_crypto_keyslot_context_new_volume_key_crypto_luks_formatbd_utils_report_startedbd_utils_report_finishedg_propagate_errorcrypt_initg_strsplitg_strv_lengthg_strfreevg_str_has_prefixstrlenmemcmpioctl__errno_locationbd_utils_report_progresssleepcrypt_get_pbkdf_defaultcrypt_set_pbkdf_typeg_propagate_prefixed_errormemsetcrypt_formatcrypt_format_luks2_opalcrypt_keyslot_add_by_volume_keycrypt_keyfile_device_readcrypt_safe_freebd_crypto_luks_formatbd_crypto_luks_open_flagscrypt_loadcrypt_activate_by_passphrasecrypt_activate_by_keyringstrchrbd_crypto_luks_openbd_crypto_luks_closecrypt_deactivatebd_crypto_luks_add_keycrypt_keyslot_add_by_passphrasebd_crypto_luks_remove_keycrypt_keyslot_destroybd_crypto_luks_change_keycrypt_keyslot_change_by_passphrasebd_crypto_luks_resizecrypt_get_active_devicecrypt_resizecrypt_get_typebd_crypto_luks_suspendcrypt_suspendbd_crypto_luks_resumecrypt_resume_by_passphrasebd_crypto_luks_kill_slotbd_crypto_luks_header_backupcrypt_header_backupbd_crypto_luks_header_restorecrypt_header_restorebd_crypto_luks_check_labelbd_crypto_luks_set_labelcrypt_set_labelbd_crypto_luks_set_uuidcrypt_set_uuidbd_crypto_luks_convertcrypt_convertbd_crypto_luks_set_persistent_flagscrypt_persistent_flags_setbd_crypto_luks_infocrypt_get_ciphercrypt_get_cipher_modecrypt_get_uuidcrypt_get_device_namecrypt_get_sector_sizecrypt_get_data_offsetcrypt_get_hw_encryption_typeblkid_do_probeblkid_probe_has_valuebd_crypto_bitlk_infobd_crypto_integrity_infocrypt_get_integrity_infobd_crypto_luks_token_infog_ptr_array_newcrypt_token_maxcrypt_token_statuscrypt_keyslot_maxcrypt_token_is_assignedg_ptr_array_addg_ptr_array_freebd_crypto_integrity_formatg_path_get_basenameg_random_intcrypt_get_dircrypt_activate_by_volume_keycrypt_wipebd_crypto_integrity_openbd_crypto_integrity_closebd_crypto_keyring_add_keyadd_keybd_crypto_device_seems_encryptedreadbd_crypto_tc_open_flagsbd_crypto_tc_openbd_crypto_tc_closebd_crypto_escrow_devicebd_crypto_bitlk_open_flagsbd_crypto_bitlk_openbd_crypto_bitlk_closebd_crypto_fvault2_open_flagsbd_crypto_fvault2_openbd_crypto_fvault2_closebd_crypto_opal_is_supportedbd_crypto_opal_wipe_devicecrypt_wipe_hw_opalbd_crypto_opal_formatbd_crypto_opal_reset_deviceg_prefix_errorfsync__EH_FRAME_LIST_END___DYNAMIC 88 obo44%o/ 7,,ABX-X- K2 8 8SPPa`S`Sd km]\q,,w//}@@@0())-X0U libbd_fs.solibbd_fs.so.3.0.0 libbd_fs.so.3libbd_fs.so.3.0.0libbd_fs.so.3.0.0DELF>@=@8 @@@@PP@ ( pppPPRtdPtdQtd "& >KZv .JXh} 0:EOYr )@^mP`q(J2 3L&aq 1 S f x    Ran +DWm}/Eew",C^|O]!2>S^j  pE  \ ; @{ + #~ n  |  9 ' `& D  `ZK    # N  w;   lM  x= `((  1X  Pv` p  }n    # [  `  +  M  ?f &8 @1 U @+r #  X@  ? 0V=V %8y `w P&8  0|  @lg 0+j  k/  pY 30  @~ p*%  p   j    \ @=# p p#  Y  @7 0= M &8 #^ # 3 031 #  \    D5 ` p2I #k  D  p]H8   @{  n+  b =  О#'   X   mn  r = h W p +C  ~# 9 1 1 p\* *CF  -w p#|  j  o A  6 0"9 # 029 #= M      b &8x Pj  {    V `p P+P #  0 + @+L  '8Y  P P  к+  p* J  qO zX  [  @ (8 ,  P2 3  Z^ d F ^ f @+  Pg=E %= 0PA A A uuu u' & H `(!T$@!`@!D "@  pT BH@a@AQ`E P0LA(B  @@( @"`8 ! D!0 "0`DA!@ " (!!$(),/39;TDێtYG?jgVĜ~ s"L S-2 1$OL[ھrlU-\،^)1H׳v`` Ӓ]Ư\y?9p"`:l@7bv *#46c)_&}Тm>r7B̜)&7Y5R[/T-uTV`myXbtAW>G_hbl-_3io,jo ~=~ٌ(8\:f]cնsxub(P<sz:%lbb! MfP .45;="+6=:=iIj!i!ClYw!bwb,h֛fr(b )򸭭}#xv6fFa6Ԭ%?Xvl2S!Zv-M<:++lDxCS\,_k' Af"[{"<\_҅WuPz_?xTQ"/EQ"cʃPѐtApɞgl.3COv uHgcՒF=.lr=+#__register_frame_info__cxa_finalize__deregister_frame_infog_mutex_lockg_mutex_unlockbd_utils_check_util_versiong_prefix_errorbd_utils_exec_error_quarkg_set_errorg_clear_errorbd_utils_have_kernel_modulebd_utils_module_error_quarkbd_utils_dbus_service_availableg_bus_get_syncg_variant_newg_dbus_connection_call_syncg_variant_getg_variant_unrefg_variant_get_stringbd_utils_version_cmpg_find_program_in_pathbd_utils_exec_and_capture_outputg_error_matchesg_strdupg_regex_newg_regex_matchg_regex_unrefg_match_info_freeg_match_info_fetchg_strchugg_strchompg_strcmp0g_strrstrg_freebd_fs_error_quarkg_quark_from_static_stringbd_fs_initmnt_init_debugbd_fs_closebd_fs_is_tech_availg_set_error_literalfsynccloseblkid_new_probeopen__errno_locationstrerror_lblkid_free_probeblkid_probe_set_deviceblkid_probe_enable_partitionsblkid_do_probeblkid_probe_has_valueblkid_probe_lookup_valueg_str_is_asciig_ascii_strdownuuid_parsebd_fs_ext2_info_copyg_malloc0_nbd_fs_ext3_info_copybd_fs_ext4_info_copybd_fs_ext2_info_freebd_fs_ext3_info_freebd_fs_ext4_info_freeg_ptr_array_newbd_extra_arg_newg_ptr_array_addbd_extra_arg_copyg_ptr_array_freebd_fs_ext2_mkfsbd_utils_exec_and_report_errorbd_fs_ext3_mkfsbd_fs_ext4_mkfsbd_fs_ext2_checkbd_utils_prog_reporting_initializedbd_utils_exec_and_report_progressbd_utils_exec_and_report_status_errorbd_fs_ext3_checkbd_fs_ext4_checkbd_fs_ext2_repairbd_utils_log_formatbd_fs_ext3_repairbd_fs_ext4_repairbd_fs_ext2_set_labelbd_fs_ext3_set_labelbd_fs_ext4_set_labelbd_fs_ext2_check_labelstrlenbd_fs_ext3_check_labelbd_fs_ext4_check_labelbd_fs_ext2_set_uuidbd_fs_ext3_set_uuidbd_fs_ext4_set_uuidbd_fs_ext2_check_uuidbd_fs_ext3_check_uuidbd_fs_ext4_check_uuidbd_fs_ext2_get_infounix_io_managerext2fs_openg_strndupext2fs_blocks_countext2fs_free_blocks_countext2fs_close_freebd_fs_ext3_get_infobd_fs_ext4_get_infobd_fs_ext2_resizeg_strdup_printfbd_fs_ext3_resizebd_fs_ext4_resizebd_fs_ext2_get_min_sizeg_strsplitg_str_has_prefixmemcmpg_strv_lengthg_ascii_strtoullg_strfreevbd_fs_ext3_get_min_sizebd_fs_ext4_get_min_sizeg_ascii_strtolle2p_uuid2strbd_fs_supported_filesystemsbd_fs_wipebd_utils_report_startedbd_utils_report_finishedg_propagate_errorg_usleepblkid_probe_set_partitions_flagsblkid_probe_enable_superblocksblkid_probe_set_superblocks_flagsblkid_do_safeprobeblkid_reset_probeblkid_do_wipebd_fs_cleanbd_fs_get_fstypestrncmpbd_fs_resizeg_assertion_messageg_assertion_message_exprbd_fs_xfs_repairbd_fs_xfs_checkbd_fs_xfs_set_labelbd_fs_xfs_check_labelbd_fs_xfs_set_uuidbd_fs_xfs_check_uuidbd_fs_vfat_resizebd_fs_vfat_repairbd_fs_vfat_checkbd_fs_vfat_check_labelbd_fs_vfat_set_labelbd_fs_vfat_set_uuidbd_fs_vfat_check_uuidbd_fs_ntfs_resizebd_fs_ntfs_repairbd_fs_ntfs_checkbd_fs_ntfs_check_labelbd_fs_ntfs_set_labelbd_fs_ntfs_set_uuidbd_fs_ntfs_check_uuidbd_fs_f2fs_repairbd_fs_f2fs_checkbd_fs_f2fs_check_labelbd_fs_nilfs2_set_labelbd_fs_nilfs2_check_labelbd_fs_nilfs2_set_uuidbd_fs_nilfs2_check_uuidbd_fs_exfat_repairbd_fs_exfat_checkbd_fs_exfat_set_labelbd_fs_exfat_check_labelbd_fs_exfat_set_uuidbd_fs_exfat_check_uuidbd_fs_btrfs_repairbd_fs_btrfs_checkbd_fs_btrfs_check_labelbd_fs_btrfs_set_uuidbd_fs_btrfs_check_uuidbd_fs_udf_set_labelbd_fs_udf_check_labelbd_fs_udf_set_uuidbd_fs_udf_check_uuidbd_fs_repairbd_fs_checkbd_fs_check_labelbd_fs_set_labelbd_fs_check_uuidbd_fs_set_uuidbd_fs_get_sizebd_fs_xfs_get_infobd_fs_xfs_info_freebd_fs_vfat_get_infobd_fs_vfat_info_freebd_fs_ntfs_get_infobd_fs_ntfs_info_freebd_fs_f2fs_get_infobd_fs_f2fs_info_freebd_fs_nilfs2_get_infobd_fs_nilfs2_info_freebd_fs_exfat_get_infobd_fs_exfat_info_freebd_fs_btrfs_info_freebd_fs_udf_get_infobd_fs_udf_info_freebd_fs_btrfs_get_infobd_fs_get_free_spacebd_fs_get_min_sizebd_fs_ntfs_get_min_sizebd_fs_can_mkfsbd_fs_can_resizebd_fs_can_checkbd_fs_can_repairbd_fs_can_set_labelbd_fs_can_set_uuidbd_fs_can_get_sizebd_fs_can_get_free_spacebd_fs_can_get_infobd_fs_can_get_min_sizebd_fs_freezebd_fs_is_mountpointioctlbd_fs_unfreezebd_fs_mkfsbd_fs_exfat_mkfsbd_fs_f2fs_mkfsbd_fs_nilfs2_mkfsbd_fs_ntfs_mkfsbd_fs_vfat_mkfsbd_fs_xfs_mkfsbd_fs_btrfs_mkfsbd_fs_udf_mkfsbd_extra_arg_list_freebd_fs_featuresbd_fs_xfs_resizebd_fs_f2fs_resizebd_fs_nilfs2_resizebd_fs_btrfs_resizebd_fs_btrfs_set_labelbd_fs_get_mountpointg_dir_make_tmpg_string_newg_string_append_printfg_string_free_and_stealbd_fs_mountg_propagate_prefixed_errorg_rmdirbd_fs_unmountmemsetgetuidgetgidgeteuidpipeforkwrite_exitwaitpidg_io_channel_unix_newg_io_channel_read_to_endg_io_channel_unrefg_io_channel_shutdownmnt_new_contextmnt_context_set_targetmnt_free_contextmnt_context_enable_lazymnt_context_enable_forcemnt_context_umountmnt_context_set_sourcemnt_context_set_fstypemnt_context_set_optionsmnt_optstr_get_optionmnt_context_enable_rwonly_mountmnt_context_mountmnt_new_tablemnt_new_cachemnt_table_set_cachemnt_free_tablemnt_free_cachemnt_table_parse_mtabmnt_table_find_sourcemnt_fs_get_targetmnt_table_find_targetsetresgidsetresuidmnt_context_get_excodemnt_context_syscall_calledmnt_context_get_syscall_errnomnt_context_tab_appliedbd_fs_ntfs_info_copyg_ascii_tablememcpystrstrstrchrsscanfbd_fs_vfat_info_copyg_ascii_strupg_str_has_suffixbd_fs_xfs_info_copyisdigitbd_fs_f2fs_info_copybd_fs_nilfs2_info_copyuuid_generateuuid_unparsebd_fs_exfat_info_copyg_utf8_validateg_convertg_random_intbd_fs_btrfs_info_copybd_utils_exec_with_inputg_match_info_fetch_namedbd_fs_udf_info_copyg_utf8_strleng_utf8_get_charg_utf8_substringg_utf8_skipg_hash_table_destroyg_str_hashg_str_equalg_hash_table_new_fullg_hash_table_insertg_hash_table_lookuplibblkid.so.1BLKID_2.15BLKID_2.17BLKID_2.21libmount.so.1MOUNT_2.19MOUNT_2.21MOUNT_2.22MOUNT_2.30libuuid.so.1UUID_1.0/shikumi/software/libunwind-23.1.2/nl9vpy8avhsg510jyqsp7mngdf0cvacp/lib:/shikumi/software/libblockdev-3.5.0/n17f2yb80anjn5nz6kbs7f5s2a73hcq2/lib:/shikumi/software/libblockdev-3.5.0/n17f2yb80anjn5nz6kbs7f5s2a73hcq2/lib:/shikumi/software/glib-2.90.1/s1r26wiyyq6d9dnqwb0d5yxx5cfs86d3/lib:/shikumi/software/libffi-3.8.0/p4xxidfd2xmdyajjx98qf7xs06h4wwmk/lib:/shikumi/software/pcre2-10.48/5f3v7r6qn0jn05mhmgd0dl7jx0dp9w1l/lib:/shikumi/software/zlib-1.3.2/5rvydc8zdy6067388cjkzydinly5nicq/lib:/shikumi/software/eudev-3.2.15/2giknpra4g70yyr2msz1nk44sggwpk6z/lib:/shikumi/software/kmod-34.2/89mg5s3x7n8f9mj1wid78dr37asw83xj/lib:/shikumi/software/zstd-1.5.7/imf8r1im3989yx5gfi06i5zd7ncinv5f/lib:/shikumi/software/xz-5.8.4/d74kkdcxq6jyp7r17fz5bp7sancrvz6k/lib:/shikumi/software/libcryptsetup-2.8.8/8b18wf5pfnglmlqng8vlg65s3ipdcl98/lib:/shikumi/software/openssl-3.5.8/8ig1bny7byn08mkiaiv2llgz3kv7c6w0/lib:/shikumi/software/json-c-0.19/s0py3fk5a4wbn74x8rjwn5sr6yrs00nv/lib:/shikumi/software/lvm2-2.03.44/ni1q51l5x3v8fb82xmnzdl5qsi2ga94x/lib:/shikumi/software/util-linux-2.42.4/r1vq57hd5ksv8b3yfnlcc3ld73fwygf8/lib:/shikumi/software/keyutils-1.6.3/z7cnlf1v2vwjk9m0jcxssgcznysb019x/lib:/shikumi/software/e2fsprogs-1.47.4/73jppb8qd844cygwx6nzlg4b802nxclp/lib:/shikumi/software/libbytesize-2.12/hbm2rm2bfysbphbk0n1zll1fwsndi84s/lib:/shikumi/software/gmp-6.3.0/gq115ij73y2racpik0xhhnwh6i3dfdsq/lib:/shikumi/software/mpfr-4.2.2/hm7psb9gjq1j3mf263yqxy46nwnn6mk4/lib:/shikumi/software/libnvme-1.16.2/2wa4n4i30prrk7f6ghxlq1p4w9g01drx/lib:/shikumi/software/keyutils-1.6.3/z7cnlf1v2vwjk9m0jcxssgcznysb019x/lib:/shikumi/software/libbytesize-2.12/hbm2rm2bfysbphbk0n1zll1fwsndi84s/liblibbd_utils.so.3libudev.so.1libkmod.so.2libgio-2.0.so.0libgobject-2.0.so.0libglib-2.0.so.0libext2fs.so.2libe2p.so.2libc.solibbd_fs.so.3q q@q`qtt t(t0t8t@tHtPtXt`thtptxtttttu utttttttuu u'u2u=u =u(=u0Gu8Lu@VuHVuP`u`luhVupluxuuzuuuuuuuuuuuuuuuu(u8u@uHuPvX v`vhv v v v+v1v$?  @"%BCDEFGHI J(K0L8M@NHOPXP`QhRpSxTUVWXYZ[\ (08@H6PX`/hp0x(#*+ (-0<8@HPX&`hpx7]  .^9 (_0`8a@bH8PcXd`hepfxghijklmnopqrstuvwxyz{ |(}0~8@HPX`hpx (08@H%s %sKernel module '%s' not available Kernel module '%s' not availableDBus service '%s' not available DBus service '%s' not availableDBus service '%s' not available in version '%s' DBus service '%s' not available in version '%s'(ss)org.freedesktop.DBus.PropertiesGetFailed to get %s property of the %s object: (v)The '%s' utility is not availableFailed to determine %s's features from: %sRequired feature %s not supported by this version of %smmmmmmmm n"n7ng-bd-fs-error-quarkUnknown technologyFailed to create a probe for the device '%s'Failed to create a probe for the device '%s': %sFailed to probe the device '%s'LABELFailed to get label for the device '%s'UUIDFailed to get UUID for the device '%s'Provided UUID is not a valid RFC-4122 UUID.ext2ext3ext4Label for ext filesystem must be at most 16 characters long.mke2fse2fscktune2fsresize2fs-L-U-n-Enodiscard-F-t-f-C1^([0-9][0-9]*) ([0-9][0-9]*) ([0-9][0-9]*) (/.*)Failed to create regex for parsing progress: %sFailed to parse progress from: %s-y-pFile system errors on %s were successfully corrected, but system reboot is advised.randomFailed to open ext4 file system%s%scleannot clean with errors%lus-P Estimated minimum size:Failed to get minimum size for '%s'ݟ5Mm͞% 'Ggқt8Xš"$D@B 'N4AAaݙ \@|Ŗ]!AAf•ͮ!=ٯuYٯext2mkfs.ext2e2fsckresize2fstune2fsdumpe2fsext3mkfs.ext3ext4mkfs.ext4xfsmkfs.xfsxfs_dbxfs_repairxfs_growfsxfs_adminvfatmkfs.vfatfsck.vfatvfat-resizefatlabelntfsmkfs.ntfsntfsfixntfsresizentfslabelntfsinfof2fsmkfs.f2fsfsck.f2fsresize.f2fsdump.f2fsnilfs2mkfs.nilfs2nilfs-resizenilfs-tuneexfatmkfs.exfatfsck.exfattune.exfatbtrfsmkfs.btrfsbtrfsckbtrfstuneudfmkudffsudflabeludfinfoStarted wiping signatures from the device '%s'Failed to create a new probeFailed to open the device '%s': %sFailed to create a probe for the device '%s'No signature detected on the device '%s'Failed to probe the device '%s'Failed to wipe signatures on the device '%s'CompletedUSAGEFailed to get usage for the device '%s'filesystemThe signature on the device '%s' is of type '%s', not 'filesystem'TYPEFailed to get filesystem type for the device '%s'Filesystem type must be specified to check label formatFilesystem type must be specified to check UUID formatNo filesystem detected on the device '%s'Error when trying to detect filesystem on '%s': Getting size of filesystem '%s' is not supported.Getting free space on filesystem '%s' is not supported.Getting minimum size of filesystem '%s' is not supported.Filesystem '%s' is not supported.generic.cdevice_operation'op != BD_FS_MKFS' should be TRUE'op != BD_FS_GET_SIZE' should be TRUEResizingRepairingCheckingSetting the label ofChecking label format forSetting UUID ofChecking UUID format for%s filesystem '%s' is not supported.Failed to get block size for device '%s'resizingblockdev.XXXXXXFailed to create temporary directory for mounting '%s'.Failed to get XFS mount options: %snosuid,nodev,ronosuid,nodevFailed to mount '%s': Failed to remove temporary mountpoint '%s'Error when trying to get mountpoint for '%s': -r-csb 0p qflagsqflags = Failed to parse XFS quota flags for %s from %s.uquota,uqnoenforce,gquota,gqnoenforce,pquota,pqnoenforce,Failed to unmount '%s' after %s it: %sFailed to get sector size for device '%s'setting labelgetting infoCreatingGetting size ofGetting free space onGetting filesystem info ofGetting minimum size ofquery_fs_operationFailed to check mountpoint '%s': '%s' doesn't appear to be a mountpoint.Failed to open the mountpoint '%s': %sFailed to %s '%s': %s.freezeunfreeze0x830fc63daf-8483-4772-8e79-3d69d8477de40x0cebd0a0a2-b9e5-4433-87c0-68b6b72699c70x07run_as_uidInvalid specification of UID: '%s'run_as_gidInvalid specification of GID: '%s'Unsupported argument for unmount: '%s'Unsupported argument for mount: '%s'Failed to set cache for mount info table.Failed to parse mount info.Not running as root, cannot change the UID/GID.Error creating pipe.Error forking.Error while waiting for process.Error while reading error.Error while reading error: %s (%d)Unknown error while reading error.Error shutting down GIO channel: %s (%d)Killed by signal %d.Error setting rgid: %mError setting ruid: %mFailed to set '%s' as target for umountFailed to set lazy unmount for '%s'Failed to set force unmount for '%s'Unmounting %sOperation not permitted.Unknown error when unmounting %s%sYou must specify at least one of: mount point, device.Failed to set '%s' as target for mountFailed to set '%s' as source for mountFailed to set '%s' as fstype for mountFailed to set '%s' as options for mountrwMounting %s (fstype %s) to %s with options: %sunspecified deviceautounspecified mountpointnoneFilesystem type %s not configured in kernel.Unknown error when mounting %s-L-nmkntfs-f-Fntfsfix-dntfslabelLabel for NTFS filesystem must be at most 128 characters long.--new-serial--new-serial=%s--new-half-serial=%sInvalid format of UUID/serial number for NTFS filesystem.UUID for NTFS filesystem must be either 8 or 16 characters long.UUID for NTFS filesystem must be a hexadecimal number.ntfsresize--no-progress-bar-s%luntfsinfo-mCan't get NTFS file system information for '%s': Device is mounted.Error when trying to get mountpoint for '%s': Cluster Size:Failed to parse NTFS file system informationVolume Size in Clusters:Free Clusters:--infoYou might resize atYou might resize at %lu bytes %*s.Failed to get minimum size for '%s'mkfs.vfat4.2--helpmkfs.fat\s+([\d\.]+).+-n-i-I--mbr=nofsck.vfat-afatlabel--versionfatlabel\s+([\d\.]+).+--reset"*/:<>?\|Label for VFAT filesystem must be at most 11 characters long.Invalid label: character '%c' not supported in VFAT labels.UUID for VFAT filesystem must be a hexadecimal number.UUID for VFAT filesystem must fit into 32 bits.-nv bytes per cluster, %lu/%lu clustersFailed to get number of FAT clusters for '%s'vfat-resize%lu-Luuid=%s-m-N-K-fmkfs.xfsxfs_repair-nxfs_admin--Label for XFS filesystem must be at most 12 characters long.Label for XFS filesystem cannot contain spaces.-Ugeneratexfs_spaceman-cinfoxfs_db-r dataFailed to parse xfs file system informationbsizeblocksxfs_growfs-D%luF2FS doesn't support setting label for an existing device.F2FS doesn't support setting UUID for an existing device.-l-tnodiscard-fmkfs.f2fsfsck.f2fs--dry-run-adump.f2fs Info: sector sizeInfo: total FS sectorsFailed to parse F2FS file system informationInfo: superblock featuresresize.f2fsCan't perform safe resize: F2FS filesystem doesn't support shrinking without using the 'safe' option-s%luLabel for F2FS filesystem must be at most 512 characters long.Too low version of %s. At least %s required.1.11.0-Vfsck.f2fs\s+([\d\.]+).+1.12.0resize.f2fs\s+([\d\.]+).+NILFS2 doesn't support filesystem check.NILFS2 doesn't support filesystem repair.-L-n-K-fmkfs.nilfs2-qnilfs-tuneLabel for nilfs2 filesystem must be at most 80 characters long.-U-l Block size:Failed to parse NILFS2 file system informationDevice sizeFree blocks countnilfs-resize-y%luexFAT currently doesn't support resizing.-nmkfs.exfatfsck.exfat-ytune.exfat-LUTF-16LEUTF-8Label for exFAT filesystem must be a valid UTF-8 string.Label for exFAT filesystem is too long.-I0x%08x0x0x%sUUID for exFAT filesystem must be a hexadecimal number.UUID for exFAT filesystem must fit into 32 bits.-v Block sector size : Number of the sectors : Number of the clusters : Failed to parse exFAT info.-L-U-K-fmkfs.btrfsbtrfsck--repairbtrfsfilesystemlabelLabel for btrfs filesystem must be at most 256 characters long.Label for btrfs filesystem cannot contain new lines.btrfstune-uy show--rawLabel:\s+(none|'(?P