(* The plug-ins. *)
let partition_types = [
Diskimage_mbr.plugin_id,
- ("MBR", Diskimage_mbr.probe);
+ ("MBR", Diskimage_mbr.callbacks);
]
let filesystem_types = [
Diskimage_ext2.plugin_id,
- ("Linux ext2/3", Diskimage_ext2.probe);
+ ("Linux ext2/3", Diskimage_ext2.callbacks);
Diskimage_linux_swap.plugin_id,
- ("Linux swap", Diskimage_linux_swap.probe);
+ ("Linux swap", Diskimage_linux_swap.callbacks);
Diskimage_linux_swsuspend.plugin_id,
- ("Linux s/w suspend", Diskimage_linux_swsuspend.probe);
+ ("Linux s/w suspend", Diskimage_linux_swsuspend.callbacks);
]
let lvm_types = [
Diskimage_lvm2.plugin_id,
- ("Linux LVM2", Diskimage_lvm2.probe, Diskimage_lvm2.list);
+ ("Linux LVM2", Diskimage_lvm2.callbacks);
]
let name_of_parts id =
let name, _ = List.assoc id filesystem_types in
name
let name_of_lvm id =
- let name, _, _ = List.assoc id lvm_types in
+ let name, _ = List.assoc id lvm_types in
name
(* Probe a device for partitions. Returns [Some parts] or [None]. *)
if !debug then eprintf "probing for partitions on %s ...\n%!" dev#name;
let rec loop = function
| [] -> None
- | (parts_plugin_id, (_, probe_fn)) :: rest ->
- try Some (probe_fn dev)
+ | (parts_plugin_id, (_, cb)) :: rest ->
+ try Some (cb.parts_cb_probe dev)
with Not_found -> loop rest
in
let r = loop partition_types in
);
r
+let parts_offset_is_free ({ parts_plugin_id = parts_name } as parts) offset =
+ let _, cb = List.assoc parts_name partition_types in
+ cb.parts_cb_offset_is_free parts offset
+
(* Probe a device for a filesystem. Returns [Some fs] or [None]. *)
let probe_for_filesystem dev =
if !debug then eprintf "probing for a filesystem on %s ...\n%!" dev#name;
let rec loop = function
| [] -> None
- | (fs_name, (_, probe_fn)) :: rest ->
- try Some (probe_fn dev)
+ | (fs_name, (_, cb)) :: rest ->
+ try Some (cb.fs_cb_probe dev)
with Not_found -> loop rest
in
let r = loop filesystem_types in
);
r
+let fs_offset_is_free ({ fs_plugin_id = fs_name } as fs) offset =
+ let _, cb = List.assoc fs_name filesystem_types in
+ cb.fs_cb_offset_is_free fs offset
+
(* Probe a device for a PV. Returns [Some lvm_name] or [None]. *)
let probe_for_pv dev =
if !debug then eprintf "probing if %s is a PV ...\n%!" dev#name;
let rec loop = function
| [] -> None
- | (lvm_name, (_, probe_fn, _)) :: rest ->
- try Some (probe_fn lvm_name dev)
+ | (lvm_name, (_, cb)) :: rest ->
+ try Some (cb.lvm_cb_probe lvm_name dev)
with Not_found -> loop rest
in
let r = loop lvm_types in
r
let list_lvs lvm_name devs =
- let _, _, list_lvs_fn = List.assoc lvm_name lvm_types in
- list_lvs_fn devs
+ let _, cb = List.assoc lvm_name lvm_types in
+ cb.lvm_cb_list_lvs devs
+
+let lvm_offset_is_free ({ lvm_plugin_id = lvm_name } as pv) offset =
+ let _, cb = List.assoc lvm_name lvm_types in
+ cb.lvm_cb_offset_is_free pv offset
(*----------------------------------------------------------------------*)
(* Create machine description. *)
eprintf "/* Use 'dot -Tpng foo.dot > foo.png' to convert to a png file. */\n";
eprintf "digraph G {\n";
print tree;
- eprintf "}\n";
+ eprintf "}\n%!";
type owner =
[ `Filesystem of filesystem
| `PhysicalVolume of pv ]
(* A segment describes the owner of a range of disk addresses. *)
-type segment =
- int63 * int63 * (* disk offset, size of segment *)
- owner * (* owner *)
- int63 (* owner offset *)
+type segment = owner * int63 (* owner, owner offset *)
type interval = int63 * int63 (* start point, end point (bytes) *)
(* List of owned segments before we build the segment tree. *)
type ownership_list =
(device * (* block_device (disk) *)
- segment) list
+ (int63 * int63 * (* disk offset, size of segment *)
+ owner * int63 (* owner, owner offset *)
+ )
+ ) list
(* Ownership tables. *)
let create_ownership machine =
let rec insert_segment tree segment =
let start, size, owner, owner_offset = segment in
let seginterval = start, start +^ size in
- eprintf "inserting (%s,%s) ...\n"
- (Int63.to_string (fst seginterval))
- (Int63.to_string (snd seginterval));
+ let seg = owner, owner_offset in
+
match tree with
(* Test if we should insert into this leaf or node: *)
| Leaf (interval, segs) when interval <-< seginterval ->
- Leaf (interval, segment :: segs)
+ Leaf (interval, seg :: segs)
| Node (left, (interval, segs), right)
when interval <-< seginterval ->
- Node (left, (interval, segment :: segs), right)
+ Node (left, (interval, seg :: segs), right)
| (Leaf _) as leaf -> leaf
let printer ((sp, ep), segments) =
sprintf "[%s-%s] " (Int63.to_string sp) (Int63.to_string ep) ^
String.concat ";"
- (List.map (fun (_, _, owner,_) -> string_of_owner owner)
+ (List.map (fun (owner,_) -> string_of_owner owner)
segments)
in
print_binary_tree printer printer tree
(* Return the ownership structure. *)
ownership
-let get_owners_lookup machine ownership disk =
+let get_owners_lookup machine ownership (disk : block_device) =
(* Get the correct tree. *)
- let tree = List.assoc disk ownership in
+ let tree = List.assoc (disk :> device) ownership in
fun offset ->
+ (* Warning: This 'hot' code was carefully optimized based on
+ * feedback from 'gprof'. Avoid fiddling with it.
+ *)
let rec query = function
| Leaf (_, segments) -> segments
+
+ (* Try to avoid expensive '@' operator if node segments is empty: *)
+ | Node ((Leaf ((_, leftend), _) | Node (_, ((_, leftend), _), _) as left),
+ (_, []),
+ right) ->
+ let subsegments =
+ if offset < leftend then query left else query right in
+ subsegments
+
+ (* ... or a singleton: *)
+ | Node ((Leaf ((_, leftend), _) | Node (_, ((_, leftend), _), _) as left),
+ (_, [segment]),
+ right) ->
+ let subsegments =
+ if offset < leftend then query left else query right in
+ segment :: subsegments
+
+ (* Normal recursive case: *)
| Node ((Leaf ((_, leftend), _) | Node (_, ((_, leftend), _), _) as left),
(_, segments),
right) ->
let owners = query tree in
List.map (
- fun (_, _, owner, owner_offset) -> (owner, offset -^ owner_offset)
+ fun (owner, owner_offset) -> (owner, offset -^ owner_offset)
) owners
+
+(* Find out if a disk offset is free.
+ * Current algorithm just checks that at least one owner says
+ * it is free. We could be smarter about this.
+ *)
+let offset_is_free owners =
+ List.exists (
+ function
+ | `Filesystem fs, offset -> fs_offset_is_free fs offset
+ | `Partitions parts, offset -> parts_offset_is_free parts offset
+ | `PhysicalVolume pv, offset -> lvm_offset_is_free pv offset
+ ) owners
git.annexia.org / virt-df.git / blobdiff