1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
(* guestfs-inspection
* Copyright (C) 2009-2020 Red Hat Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*)
open Printf
open Std_utils
(* Enumerate block devices (including MD, LVM, LDM and partitions) and use
* vfs-type to check for filesystems on devices. Some block devices cannot
* contain filesystems, so we filter them out.
*)
let rec list_filesystems () =
let has_lvm2 = Optgroups.lvm2_available () in
let has_ldm = Optgroups.ldm_available () in
let ret = ref [] in
(* Devices. *)
let devices = Devsparts.list_devices () in
let devices = List.filter is_not_partitioned_device devices in
List.iter (check_with_vfs_type ret) devices;
(* Device-mapper devices.
* We include these in case any encrypted devices contain
* direct filesystems.
*)
let devices = Lvm_dm.list_dm_devices () in
let devices = List.filter is_not_partitioned_device devices in
List.iter (check_with_vfs_type ret) devices;
(* Partitions. *)
let partitions = Devsparts.list_partitions () in
let partitions = List.filter is_partition_can_hold_filesystem partitions in
List.iter (check_with_vfs_type ret) partitions;
(* MD. *)
let mds = Md.list_md_devices () in
let mds = List.filter is_not_partitioned_device mds in
List.iter (check_with_vfs_type ret) mds;
(* LVM. *)
if has_lvm2 then (
let lvs = Lvm.lvs () in
List.iter (check_with_vfs_type ret) lvs
);
(* LDM. *)
if has_ldm then (
let ldmvols = Ldm.list_ldm_volumes () in
List.iter (check_with_vfs_type ret) ldmvols
);
!ret
(* Look to see if device can directly contain filesystem (RHBZ#590167).
* Partitioned devices cannot contain filesystem, so we will exclude
* such devices.
*)
and is_not_partitioned_device device =
let device =
if String.is_prefix device "/dev/mapper/" then
Unix_utils.Realpath.realpath device
else
device in
assert (String.is_prefix device "/dev/");
let dev_name = String.sub device 5 (String.length device - 5) in
let dev_dir = "/sys/block/" ^ dev_name in
(* Open the device's directory under /sys/block/<dev_name> and
* look for entries starting with <dev_name>, eg. /sys/block/sda/sda1
*)
let is_device_partition file = String.is_prefix file dev_name in
let files = Array.to_list (Sys.readdir dev_dir) in
let has_partition = List.exists is_device_partition files in
not has_partition
(* We should ignore Windows Logical Disk Manager (LDM) partitions,
* because these are members of a Windows dynamic disk group. Trying
* to read them will cause errors (RHBZ#887520). Assuming that
* libguestfs was compiled with ldm support, we'll get the filesystems
* on these later. We also ignore Microsoft Reserved Partition and
* Windows Snapshot Partition as well as MBR extended partitions.
*)
and is_partition_can_hold_filesystem partition =
let device = Devsparts.part_to_dev partition in
let partnum = Devsparts.part_to_partnum partition in
let parttype = Parted.part_get_parttype device in
let is_gpt = parttype = "gpt" in
let is_mbr = parttype = "msdos" in
let is_gpt_or_mbr = is_gpt || is_mbr in
if is_gpt_or_mbr then (
if is_mbr_extended parttype device partnum then
false
else (
(* MBR partition id will be converted into corresponding GPT type. *)
let gpt_type = Parted.part_get_gpt_type device partnum in
match gpt_type with
(* Windows Logical Disk Manager metadata partition. *)
| "5808C8AA-7E8F-42E0-85D2-E1E90434CFB3"
(* Windows Logical Disk Manager data partition. *)
| "AF9B60A0-1431-4F62-BC68-3311714A69AD"
(* Microsoft Reserved Partition. *)
| "E3C9E316-0B5C-4DB8-817D-F92DF00215AE"
(* Windows Snapshot Partition. *)
| "CADDEBF1-4400-4DE8-B103-12117DCF3CCF" -> false
| _ -> true
)
)
else true
and is_mbr_extended parttype device partnum =
parttype = "msdos" &&
Parted.part_get_mbr_part_type device partnum = "extended"
(* Use vfs-type to check for a filesystem of some sort of [device].
* Appends (device, vfs_type) to the ret parameter (there may be
* multiple devices found in the case of btrfs).
*)
and check_with_vfs_type ret device =
let mountable = Mountable.of_device device in
let vfs_type =
try Blkid.vfs_type mountable
with exn ->
if verbose () then
eprintf "check_with_vfs_type: %s: %s\n"
device (Printexc.to_string exn);
"" in
if vfs_type = "" then
List.push_back ret (mountable, "unknown")
(* Ignore all "*_member" strings. In libblkid these are returned
* for things which are members of some RAID or LVM set, most
* importantly "LVM2_member" which is a PV.
*)
else if String.is_suffix vfs_type "_member" then
()
(* Ignore encrypted partitions. These are also containers, as above. *)
else if vfs_type = "crypto_LUKS" || vfs_type = "BitLocker" then
()
(* A single btrfs device can turn into many volumes. *)
else if vfs_type = "btrfs" then (
let vols = Btrfs.btrfs_subvolume_list mountable in
(* Filter out the default subvolume. You can access that by
* simply mounting the whole device, so we will add the whole
* device at the beginning of the returned list instead.
*)
let default_volume = Btrfs.btrfs_subvolume_get_default mountable in
let vols =
List.filter (
fun { Structs.btrfssubvolume_id = id } -> id <> default_volume
) vols in
(* whole device = default volume *)
List.push_back ret (mountable, vfs_type);
(* subvolumes *)
List.push_back_list ret (
List.map (
fun { Structs.btrfssubvolume_path = path } ->
let mountable = Mountable.of_btrfsvol device path in
(mountable, "btrfs")
) vols
)
)
else
List.push_back ret (mountable, vfs_type)
|
