object
method virtual name : string
(** Return some printable name for the device. *)
+
method virtual size : Int63.t
(** Return the size of the device in bytes.
(** [read offset len] reads len bytes starting at offset.
Note: A default implementation is provided for [read],
- but it is fairly inefficient because it uses {!mapblock} to
+ but it is fairly inefficient because it uses {!map_block} to
map each block in the request. *)
method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
(** [read_bitstring] is the same as [read] but returns
a pa_bitmatch-style bitstring. *)
+
method virtual blocksize : Int63.t
(** [blocksize] returns the natural block size of the device. *)
- method virtual mapblock : Int63.t -> (device * Int63.t) list
- (** [mapblock] describes how a block in this device is
+ method virtual map_block : Int63.t -> (device * Int63.t) list
+ (** [map_block] describes how a block in this device is
mapped down to any underlying device(s).
Returns [[]] (empty list) if there is no underlying
Normally the returned list has length 1, but in cases
such as mirroring you can have the same block mapped
to several underlying devices. *)
+
+ method virtual contiguous : Int63.t -> Int63.t
+ (** [contiguous offset] returns the number of contiguous
+ {i bytes} starting at byte [offset] on this device,
+ before (eg.) end of device or some discontinuity in
+ the mapping table occurs.
+
+ This method and {!map_block} allow callers to determine how
+ high level blocks map to low level disk images efficiently
+ (complex striping and interleaving patterns can make the
+ process much less efficient however). *)
end
(**
A virtual (or physical!) device, encapsulating any translation
that has to be done to access the device. eg. For partitions
there is a simple offset, but for LVM you may need complicated
table lookups.
-
+
Note this very rare use of OOP in OCaml!
*)
method read : Int63.t -> Int63.t -> string
method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
method blocksize : Int63.t
- method mapblock : Int63.t -> (device * Int63.t) list
+ method map_block : Int63.t -> (device * Int63.t) list
+ method contiguous : Int63.t -> Int63.t
method close : unit -> unit
(** Close the device, freeing up the file descriptor. *)
end
method read : Int63.t -> Int63.t -> string
method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
method blocksize : Int63.t
- method mapblock : Int63.t -> (device * Int63.t) list
+ method map_block : Int63.t -> (device * Int63.t) list
+ method contiguous : Int63.t -> Int63.t
end
(** A concrete device which maps a linear part of an underlying device.
method read : Int63.t -> Int63.t -> string
method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
method blocksize : Int63.t
- method mapblock : Int63.t -> (device * Int63.t) list
+ method contiguous : Int63.t -> Int63.t
+ method map_block : Int63.t -> (device * Int63.t) list
end
(** Change the blocksize of an existing device. *)
and partitions = {
parts_plugin_id : parts_plugin_id; (** Partitioning scheme. *)
+ parts_dev : device; (** Partitions (whole) device. *)
parts : partition list; (** Partitions. *)
}
and partition = {
and pv = {
lvm_plugin_id : lvm_plugin_id; (** The LVM plug-in which detected
this. *)
+ pv_dev : device; (** Device covering whole PV. *)
pv_uuid : string; (** UUID. *)
}
and lv = {
val name_of_lvm : lvm_plugin_id -> string
(** Convert plug-in IDs to printable strings. *)
-(** {2 Scanning functions} *)
+(** {2 Functions} *)
+
+(** {3 Create 'machine'} *)
val open_machine : string -> (string * string) list -> machine
(** [open_machine m_name devs]
opened by these devices.
*)
+(** {3 Scanning for filesystems} *)
+
val scan_machine : machine -> machine
(** This does a complete scan of all devices owned by a machine,
identifying all partitions, filesystems, physical and logical
Returns an updated {!machine} structure with the scan results.
*)
+(** {3 Create ownership tables} *)
+
+type ownership
+
+val create_ownership : machine -> ownership
+ (** This creates the ownership tables (mapping disk blocks to the
+ 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. *)
+
(** {2 Debugging} *)
val debug : bool ref
git.annexia.org / virt-df.git / blobdiff