1 (* Diskimage library for reading disk images.
2 (C) Copyright 2007-2008 Richard W.M. Jones, Red Hat Inc.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 include Diskimage_utils
28 (* Use as the natural block size for disk images, but really we should
29 * use the 'blockdev -getbsz' command to find the real block size.
31 let disk_block_size = ~^512
33 let partition_types = [
34 Diskimage_mbr.plugin_id,
35 ("MBR", Diskimage_mbr.probe);
38 let filesystem_types = [
39 Diskimage_ext2.plugin_id,
40 ("Linux ext2/3", Diskimage_ext2.probe);
41 Diskimage_linux_swap.plugin_id,
42 ("Linux swap", Diskimage_linux_swap.probe);
46 Diskimage_lvm2.plugin_id,
47 ("Linux LVM2", Diskimage_lvm2.probe, Diskimage_lvm2.list);
50 let name_of_parts id =
51 let name, _ = List.assoc id partition_types in
53 let name_of_filesystem id =
54 let name, _ = List.assoc id filesystem_types in
57 let name, _, _ = List.assoc id lvm_types in
60 (* Probe a device for partitions. Returns [Some parts] or [None]. *)
61 let probe_for_partitions dev =
62 if !debug then eprintf "probing for partitions on %s ...\n%!" dev#name;
63 let rec loop = function
65 | (parts_plugin_id, (_, probe_fn)) :: rest ->
66 try Some (probe_fn dev)
67 with Not_found -> loop rest
69 let r = loop partition_types in
72 | None -> eprintf "no partitions found on %s\n%!" dev#name
73 | Some { parts_plugin_id = name; parts = parts } ->
74 eprintf "found %d %s partitions on %s\n"
75 (List.length parts) name dev#name
79 (* Probe a device for a filesystem. Returns [Some fs] or [None]. *)
80 let probe_for_filesystem dev =
81 if !debug then eprintf "probing for a filesystem on %s ...\n%!" dev#name;
82 let rec loop = function
84 | (fs_name, (_, probe_fn)) :: rest ->
85 try Some (probe_fn dev)
86 with Not_found -> loop rest
88 let r = loop filesystem_types in
91 | None -> eprintf "no filesystem found on %s\n%!" dev#name
93 eprintf "found a filesystem on %s:\n" dev#name;
94 eprintf "\t%s\n%!" fs.fs_plugin_id
98 (* Probe a device for a PV. Returns [Some lvm_name] or [None]. *)
99 let probe_for_pv dev =
100 if !debug then eprintf "probing if %s is a PV ...\n%!" dev#name;
101 let rec loop = function
103 | (lvm_name, (_, probe_fn, _)) :: rest ->
104 try Some (probe_fn lvm_name dev)
105 with Not_found -> loop rest
107 let r = loop lvm_types in
110 | None -> eprintf "no PV found on %s\n%!" dev#name
111 | Some { lvm_plugin_id = name } ->
112 eprintf "%s contains a %s PV\n%!" dev#name name
116 let list_lvs lvm_name devs =
117 let _, _, list_lvs_fn = List.assoc lvm_name lvm_types in
120 (* Create machine description. *)
121 let open_machine name disks =
122 let disks = List.map (
124 let dev = new block_device path disk_block_size (* XXX *) in
125 { d_name = name; d_dev = dev; d_content = `Unknown }
127 { m_name = name; m_disks = disks; m_lv_filesystems = [] }
129 let close_machine { m_disks = m_disks } =
130 (* Only close the disks, assume all other devices are derived from them. *)
131 List.iter (fun { d_dev = d_dev } -> d_dev#close ()) m_disks
133 let scan_machine ({ m_disks = m_disks } as machine) =
134 let m_disks = List.map (
135 fun ({ d_dev = dev } as disk) ->
136 let dev = (dev :> device) in
137 (* See if it is partitioned first. *)
138 let parts = probe_for_partitions dev in
141 { disk with d_content = `Partitions parts }
143 (* Not partitioned. Does it contain a filesystem? *)
144 let fs = probe_for_filesystem dev in
147 { disk with d_content = `Filesystem fs }
149 (* Not partitioned, no filesystem, is it a PV? *)
150 let pv = probe_for_pv dev in
153 { disk with d_content = `PhysicalVolume lvm_name }
155 disk (* Spare/unknown. *)
158 (* Now we have either detected partitions or a filesystem on each
159 * physical device (or perhaps neither). See what is on those
162 let m_disks = List.map (
164 | ({ d_dev = dev; d_content = `Partitions parts } as disk) ->
167 if p.part_status = Bootable || p.part_status = Nonbootable then (
168 let fs = probe_for_filesystem p.part_dev in
171 { p with part_content = `Filesystem fs }
174 let pv = probe_for_pv p.part_dev in
177 { p with part_content = `PhysicalVolume lvm_name }
179 p (* Spare/unknown. *)
182 let parts = { parts with parts = ps } in
183 { disk with d_content = `Partitions parts }
187 (* LVM filesystem detection
189 * Look for all disks/partitions which have been identified as PVs
190 * and pass those back to the respective LVM plugin for LV detection.
192 * (Note - a two-stage process because an LV can be spread over
193 * several PVs, so we have to detect all PVs belonging to a
196 * XXX To deal with RAID (ie. md devices) we will need to loop
197 * around here because RAID is like LVM except that they normally
198 * present as block devices which can be used by LVM.
200 (* First: LV detection.
201 * Find all physical volumes, can be disks or partitions.
203 let pvs_on_disks = List.filter_map (
206 d_content = `PhysicalVolume pv } -> Some (pv, (d_dev :> device))
209 let pvs_on_partitions = List.map (
211 | { d_content = `Partitions { parts = parts } } ->
214 | { part_dev = part_dev;
215 part_content = `PhysicalVolume pv } ->
221 let lvs = List.concat (pvs_on_disks :: pvs_on_partitions) in
223 (* Second: filesystem on LV detection.
224 * Group the LVs by plug-in type.
226 let cmp (a,_) (b,_) = compare a b in
227 let lvs = List.sort ~cmp lvs in
228 let lvs = group_by lvs in
231 List.map (fun (pv, devs) -> list_lvs pv.lvm_plugin_id devs) lvs in
232 let lvs = List.concat lvs in
234 (* lvs is a list of potential LV devices. Now run them through the
235 * probes to see if any contain filesystems.
239 fun ({ lv_dev = dev } as lv) ->
240 match probe_for_filesystem dev with
241 | Some fs -> Some (lv, fs)
247 m_lv_filesystems = filesystems }