]
and partitions = {
- parts_plugin_id : parts_plugin_id; (** Partitioning scheme. *)
+ parts_cb : partitioner_callbacks; (** Partitioning scheme. *)
parts_dev : device; (** Partitions (whole) device. *)
parts : partition list; (** Partitions. *)
}
]
and filesystem = {
- fs_plugin_id : fs_plugin_id; (** Filesystem type. *)
+ fs_cb : filesystem_callbacks; (** Filesystem type. *)
fs_dev : device; (** Device containing the filesystem. *)
fs_blocksize : Int63.t; (** Block size (bytes). *)
fs_blocks_total : Int63.t; (** Total blocks. *)
(** A filesystem, with superblock contents. *)
and pv = {
- lvm_plugin_id : lvm_plugin_id; (** The LVM plug-in which detected
+ pv_cb : lvm_callbacks; (** The LVM plug-in which detected
this. *)
pv_dev : device; (** Device covering whole PV. *)
pv_uuid : string; (** UUID. *)
}
(** Physical and logical volumes as used by LVM plug-ins. *)
-and parts_plugin_id
-and fs_plugin_id
-and lvm_plugin_id
- (** Opaque IDs used to refer to the plug-ins. *)
-
-val name_of_parts : parts_plugin_id -> string
-val name_of_filesystem : fs_plugin_id -> string
-val name_of_lvm : lvm_plugin_id -> string
- (** Convert plug-in IDs to printable strings. *)
+and partitioner_callbacks
+and filesystem_callbacks
+and lvm_callbacks
(** {2 Functions} *)
+val name_of_filesystem : filesystem -> string
+ (** [name_of_filesystem fs] returns a printable name for
+ the filesystem.
+ *)
+
(** {3 Create 'machine'} *)
val open_machine : string -> (string * string) list -> machine
LV filesystems in the returned structure.
*)
+val open_machine_from_devices : string -> (string * block_device) list ->
+ machine
+ (** This is the same as {!open_machine} except that instead
+ of passing a path you should pass a {!block_device} object. *)
+
val close_machine : machine -> unit
(** This is a convenience function which calls the [dev#close]
method on any open {!block_device}s owned by the machine. This just
ultimate filesystem, etc., which owns each one).
*)
+type owner =
+ [ `Filesystem of filesystem
+ | `Partitions of partitions
+ | `PhysicalVolume of pv ]
+
+val get_owners_lookup : machine -> ownership -> block_device ->
+ (Int63.t -> (owner * Int63.t) list)
+ (** [get_owners_lookup machine disk] returns a specialized
+ function for looking up owners (filesystems, etc.)
+ which reside on block device [disk].
+
+ [disk] must be a block device of the machine.
+
+ The specialized lookup function that is returned
+ can be called as [lookup offset] to look up the
+ owners of byte offset [offset].
+
+ Returns a list of [(owner, owner_offset)] where [owner]
+ is the filesystem, etc., and [owner_offset] is the byte
+ offset relative to the owner.
+
+ It is common for there to be multiple owners: for example
+ in the case where a filesystem is created on a partition,
+ both the filesystem ([`Filesystem fs]) and
+ partition scheme ([`Partitions parts]) will be returned.
+
+ The specialized function is efficient. {!create_ownership}
+ creates a tree structure which allows ownership to be determined
+ in just a few steps. *)
+
+val offset_is_free : (owner * Int63.t) list -> bool
+ (** [offset_is_free owners] tests if the offset is free (unused).
+
+ If an offset is free, then it may be discarded without
+ changing the semantics of the disk image. In normal cases
+ this extends to the end of the current block, but blocksize
+ will differ for each owner, so what this really means is
+ tricky in practice. *)
+
(** {2 Debugging} *)
val debug : bool ref