OpenrelikWorkerCommon.MountUtils.BlockDevice (openrelik_worker_common v0.1.0)

Provides functionality to map a disk image file to block devices (loop or nbd) and mount them (openrelik_worker_common.mount_utils.BlockDevice).

The default minimum partition size that gets mounted is 100 MB (104_857_600 bytes).

Summary

Functions

blkinfo(bd)

Extracts device and partition information using lsblk -ba -J.

detach_device(bd)

Detaches the block device (qemu-nbd --disconnect for NBD devices or losetup --detach for loop devices).

ewfmount(bd)

Mounts an EWF image (.E01 / .EX01) using ewfmount and returns {updated_bd, raw_image_path}.

ewfumount(bd)

Unmounts an EWF FUSE mount and removes its mount directory.

get_free_nbd_device(bd)

Finds and locks a free NBD device (/dev/nbd0../dev/nbd10) in Redis until unlocked or timeout.

get_fstype(bd, devname)

Analyses the file system type of a block device or partition using blkid.

get_hostname(bd \\ nil)

Returns the hostname from the NODENAME environment variable or OS hostname.

get_mount_path(bd)

Generates a mount path under bd.mountroot respecting bd.max_mountpath_size.

is_important_partition(bd, partition)

Decides if a partition should be processed (size >= min_partition_size and supported fs type).

is_supported_fs(bd, devname)

Returns true if devname points to a block device containing a supported filesystem type.

lock_timeout_seconds()

Default Redis lock timeout in seconds (21600, 6 hours).

losetup(bd)

Maps bd.image_path to a loopback device using losetup.

max_mountpath_size()

Default maximum mount path character length (500).

max_nbd_devices()

Default maximum NBD device index (10).

min_partition_size_bytes()

Default minimum partition size in bytes (100 MB).

mount(bd, partition_name_or_opts \\ "")

Mounts a disk or one or more partitions on a mountpoint.

nbdsetup(bd)

Maps a QCOW image file to an NBD device using qemu-nbd and probes partitions with fdisk.

new(image_path, opts \\ [])

Initializes a %BlockDevice{} struct.

parse_partitions(bd)

Parses partition information from bd.blkdeviceinfo.

required_modules_loaded(bd \\ nil)

Checks if the nbd kernel module is loaded or if /dev/nbd* devices exist.

required_tools_available(bd \\ nil)

Checks if required CLI tools (lsblk, blkid, mount, qemu-nbd, sudo, fdisk, ntfsinfo) are available on PATH.

select_partitions_to_mount(bd, partition_name \\ "")

Selects partitions to mount.

setup(bd)

Sets up the BlockDevice instance: checks if the image exists, verifies required tools, configures the block device (ewfmount, qemu-nbd, or losetup), queries lsblk, and scans available partitions.

umount(bd)

Unmounts all mounted file systems, detaches the block device, unmounts any EWF FUSE mount, and releases any Redis lock.

umount_all(bd)

Unmounts all registered mountpoints and removes their directories.

Types

cmd_result()

@type cmd_result() :: %{
  returncode: integer(),
  stdout: String.t() | nil,
  stderr: String.t() | nil
}

t()

@type t() :: %OpenrelikWorkerCommon.MountUtils.BlockDevice{
  blkdevice: String.t() | nil,
  blkdeviceinfo: map() | nil,
  ewf_mount_path: String.t() | nil,
  image_path: String.t(),
  max_mountpath_size: pos_integer(),
  min_partition_size: non_neg_integer(),
  mountpoints: [String.t()],
  mountroot: String.t(),
  opts: keyword(),
  original_image_path: String.t(),
  partitions: [String.t()],
  redis_client: term(),
  redis_lock: OpenrelikWorkerCommon.MountUtils.RedisLock.t() | nil,
  redis_url: String.t(),
  supported_ewftypes: [String.t()],
  supported_fstypes: [String.t()],
  supported_qcowtypes: [String.t()]
}