07f9df8a999918bbf1faa07b28327e3aad121745
[virt-df.git] / lib / diskimage_mbr.ml
1 (* 'df' command for virtual domains.
2
3    (C) Copyright 2007 Richard W.M. Jones, Red Hat Inc.
4    http://libvirt.org/
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20    Support for Master Boot Record partition scheme.
21 *)
22
23 open Printf
24 open Unix
25 open ExtList
26
27 open Diskimage_utils
28
29 let plugin_id = "mbr"
30
31 let sector_size = 512
32 let sector_size64 = 512L
33
34 (* Maximum number of extended partitions possible. *)
35 let max_extended_partitions = 100
36
37 (* Device representing a single partition.  It just acts as an offset
38  * into the underlying device.
39  *
40  * Notes:
41  * (1) 'start'/'size' are measured in sectors.
42  * (2) 'partno' is the partition number, starting at 1
43  *     (cf. /dev/hda1 is the first partition).
44  * (3) 'dev' is the underlying block device.
45  * (4) natural blocksize to use is sector size.
46  *)
47 class partition_device partno start size dev =
48   let devname = dev#name in
49   let name = sprintf "%s%d" devname partno in
50   let start = start *^ sector_size64 in
51   let size = size *^ sector_size64 in
52 object (self)
53   inherit offset_device name start size sector_size dev
54 end
55
56 (** Probe the
57     {{:http://en.wikipedia.org/wiki/Master_boot_record}master boot record}
58     (if it is one) and read the partitions.
59
60     @raise Not_found if it is not an MBR.
61  *)
62 let rec probe dev =
63   (* Read the first sector. *)
64   let bits =
65     try dev#read_bitstring 0L sector_size
66     with exn -> raise Not_found in
67
68   (* Does this match a likely-looking MBR? *)
69   bitmatch bits with
70   | { _ : 3568 : bitstring;             (* padding to byte offset 446 *)
71       part0 : 128 : bitstring;          (* partitions *)
72       part1 : 128 : bitstring;
73       part2 : 128 : bitstring;
74       part3 : 128 : bitstring;
75       0x55 : 8; 0xAA : 8 } ->           (* MBR signature *)
76
77       (* Parse the partition table entries. *)
78       let primaries =
79         List.mapi (parse_mbr_entry dev) [part0;part1;part2;part3] in
80
81 (*
82       (* Read extended partition data. *)
83       let extendeds = List.map (
84         function
85         | { part_type = 0x05 } as part ->
86             probe_extended_partition
87               max_extended_partitions fd part part.part_lba_start
88         | part -> []
89       ) primaries in
90       let extendeds = List.concat extendeds in
91       primaries @ extendeds
92 *)
93       { parts_plugin_id = plugin_id; parts = primaries }
94
95   | { _ } ->
96       raise Not_found                   (* not an MBR *)
97
98 (* Parse a single partition table entry.  See the table here:
99  * http://en.wikipedia.org/wiki/Master_boot_record
100  *)
101 and parse_mbr_entry dev i bits =
102   bitmatch bits with
103   | { 0l : 32; 0l : 32; 0l : 32; 0l : 32 } ->
104       { part_status = NullEntry; part_type = 0;
105         part_dev = null_device; part_content = `Unknown }
106
107   | { ((0|0x80) as bootable) : 8; first_chs : 24;
108       part_type : 8; last_chs : 24;
109       first_lba : 32 : unsigned, littleendian;
110       part_size : 32 : unsigned, littleendian } ->
111       let bootable = if bootable = 0 then Nonbootable else Bootable in
112       make_mbr_entry bootable dev (i+1) part_type first_lba part_size
113
114   | { _ } ->
115       { part_status = Malformed; part_type = 0;
116         part_dev = null_device; part_content = `Unknown }
117
118 and make_mbr_entry part_status dev partno part_type first_lba part_size =
119   let first_lba = uint64_of_int32 first_lba in
120   let part_size = uint64_of_int32 part_size in
121   if !debug then
122     eprintf "make_mbr_entry: first_lba = %Lx part_size = %Lx\n%!"
123       first_lba part_size;
124   { part_status = part_status;
125     part_type = part_type;
126     part_dev = new partition_device partno first_lba part_size dev;
127     part_content = `Unknown }
128
129 (*
130 This code worked previously, but now needs some love ...
131 XXX
132
133 (* Probe an extended partition. *)
134 and probe_extended_partition max fd epart sect =
135   if max > 0 then (
136     (* Offset of the first EBR. *)
137     let ebr_offs = sect *^ sector_size in
138     (* EBR Signature? *)
139     LargeFile.lseek fd (ebr_offs +^ 510L) SEEK_SET;
140     let str = String.create 2 in
141     if read fd str 0 2 <> 2 || str.[0] != '\x55' || str.[1] != '\xAA' then
142       [] (* Not EBR *)
143     else (
144       (* Read the extended partition table entries (just 2 of them). *)
145       LargeFile.lseek fd (ebr_offs +^ 446L) SEEK_SET;
146       let str = String.create 32 in
147       if read fd str 0 32 <> 32 then
148         failwith (s_ "error reading extended partition")
149       else (
150         (* Extract partitions from the data. *)
151         let part1, part2 =
152           match List.map (get_partition str) [ 0; 16 ] with
153           | [p1;p2] -> p1,p2
154           | _ -> failwith (s_ "probe_extended_partition: internal error") in
155         (* First partition entry has offset to the start of this partition. *)
156         let part1 = { part1 with
157                         part_lba_start = sect +^ part1.part_lba_start } in
158         (* Second partition entry is zeroes if end of list, otherwise points
159          * to the next partition.
160          *)
161         if part2.part_status = NullEntry then
162           [part1]
163         else
164           part1 :: probe_extended_partition
165                      (max-1) fd epart (sect +^ part2.part_lba_start)
166       )
167     )
168   )
169   else []
170 *)
171
172 (* Ugh, fake a UInt32 -> UInt64 conversion without sign extension, until
173  * we get working UInt32/UInt64 modules in extlib.
174  *)
175 and uint64_of_int32 u32 =
176   let i64 = Int64.of_int32 u32 in
177   if u32 >= 0l then i64
178   else Int64.add i64 0x1_0000_0000_L