lib/diskimage_fat.ml

   1 (* 'df' command for virtual domains.
   2    (C) Copyright 2007 Richard W.M. Jones, Red Hat Inc.
   3    http://libvirt.org/
   4
   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.
   9
  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.
  14
  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.
  18
  19    Support for FAT32.
  20 *)
  21
  22 open Unix
  23 open Printf
  24
  25 open Diskimage_impl
  26 open Int63.Operators
  27
  28 let id = "fat"
  29
  30 (* Private data that we'll save about the FAT filesystem. *)
  31 type fat = {
  32   fat_dev : device;                     (* Device. *)
  33   fat_blocksize : int63;                (* Cluster size. *)
  34   fat_sectorsize : int63;               (* Sector size. *)
  35   fat_sectors_per_cluster : int63;      (* Sectors per cluster. *)
  36   fat_number_of_sectors : int63;        (* Total number of sectors in dev. *)
  37   fat_reserved_sectors : int63;         (* Offset of the first FAT. *)
  38   fat_sectors_per_fat : int63;          (* Size of each FAT. *)
  39   fat_root_directory_cluster : int63;   (* Cluster offset of root dir. *)
  40 }
  41
  42 (* Private data functions. *)
  43 let attach_private_data, get_private_data =
  44   private_data_functions (fun {fs_cb = {fs_cb_uq = u}} -> u)
  45
  46 (* FAT entries. *)
  47 type fat_entry =
  48   | Free                                (* 0x0 *)
  49   | Reserved1                           (* 0x1 *)
  50   | Used of int63                       (* Used, points to next cluster *)
  51   | Reserved of int63                   (* 0x_FFFFFF0 - 0x_FFFFFF6 *)
  52   | Bad                                 (* Bad / reserved 0x_FFFFFF7 *)
  53   | Last of int63                       (* Last cluster in file *)
  54
  55 let rec probe dev =
  56   let fs = probe_superblock dev in
  57   fs
  58
  59 and probe_superblock dev =
  60     (* Load the boot sector / superblock. *)
  61   let bits = dev#read_bitstring ~^0 ~^512 in
  62
  63   (* Standard stuff in a boot sector. *)
  64   bitmatch bits with
  65   | { _ : 24;                           (* Jump to boot up code. *)
  66       oem_name : 64 : string;           (* OEM name. *)
  67       bytes_per_sector : 16 : littleendian;
  68       sectors_per_cluster : 8 : littleendian;
  69       reserved_sectors : 16 : littleendian;
  70       2 : 8;                            (* Number of FATs. *)
  71       0 : 16;                           (* Root dir entries, 0 for FAT32 *)
  72       0 : 16;                           (* Old number of sectors - unused. *)
  73       _ : 8;                            (* Media type, probably 'f8' = HDD *)
  74       _ : 16;                           (* Sectors per FAT, not for FAT32 *)
  75       _ : 16;                           (* Sectors per track. *)
  76       _ : 16;                           (* Heads. *)
  77       _ : 32;                           (* Hidden sectors. *)
  78       number_of_sectors : 32 : littleendian;
  79       sectors_per_fat : 32 : littleendian;
  80       _ : 16;                           (* FAT32 flags *)
  81       _ : 16;                           (* FAT32 version *)
  82       root_directory_cluster : 32 : littleendian;
  83       _ : 16;                           (* FS information sector *)
  84       _ : 16;                           (* Backup of boot sector *)
  85       _ : 12*8 : bitstring;             (* Reserved *)
  86       _ : 8;                            (* Physical drive number *)
  87       _ : 8;                            (* Reserved *)
  88       _ : 8;                            (* Extended boot signature *)
  89       serial : 32 : littleendian;       (* Serial number. *)
  90       volume_label : 88 : string;       (* Volume label. *)
  91       "FAT32   " : 64 : string;         (* FAT32 identifier. *)
  92       _ : 420*8 : bitstring;            (* Boot code. *)
  93       0x55AA : 16 } ->                  (* End of bootsector magic. *)
  94
  95       let blocksize = bytes_per_sector * sectors_per_cluster in
  96
  97       (* FAT32 forbids cluster size > 32K. *)
  98       if blocksize > 32768 then (
  99         prerr_endline "FAT: cluster size > 32K";
 100         raise Not_found
 101       );
 102
 103       if !debug then
 104         eprintf "%s: found FAT32 filesystem with clustersize = %d, label %s\n"
 105           dev#name blocksize volume_label;
 106
 107       let blocksize = Int63.of_int blocksize in
 108       let sectorsize = Int63.of_int bytes_per_sector in
 109       let sectors_per_cluster = Int63.of_int sectors_per_cluster in
 110       let number_of_sectors = Int63.of_int32 number_of_sectors in
 111       let reserved_sectors = Int63.of_int reserved_sectors in
 112       let sectors_per_fat = Int63.of_int32 sectors_per_fat in
 113       let root_directory_cluster = Int63.of_int32 root_directory_cluster in
 114
 115       (* The blocksize of the filesystem is likely to be quite different
 116        * from that of the underlying device, so create an overlay device
 117        * with the natural filesystem blocksize.
 118        *)
 119       let fs_dev = new blocksize_overlay blocksize dev in
 120
 121       let fat = {
 122         fat_dev = fs_dev;
 123         fat_blocksize = blocksize;
 124         fat_sectorsize = sectorsize;
 125         fat_sectors_per_cluster = sectors_per_cluster;
 126         fat_number_of_sectors = number_of_sectors;
 127         fat_reserved_sectors = reserved_sectors;
 128         fat_sectors_per_fat = sectors_per_fat;
 129         fat_root_directory_cluster = root_directory_cluster
 130       } in
 131
 132       (* Parse the first FAT to get free space. *)
 133       let blocks_used, blocks_avail = parse_fat_freespace fat in
 134
 135       (* Calculate reserved space. *)
 136       let blocks_reserved =
 137         let sectors_reserved = reserved_sectors +^ ~^2 *^ sectors_per_fat in
 138         sectors_reserved *^ sectors_per_cluster in
 139
 140       (* Create a filesystem structure. *)
 141       let fs = {
 142         fs_cb = callbacks ();
 143         fs_dev = fs_dev;
 144         fs_blocksize = blocksize;
 145         fs_blocks_total = number_of_sectors *^ sectorsize /^ blocksize;
 146         fs_is_swap = false;
 147         fs_blocks_reserved = blocks_reserved;
 148         fs_blocks_avail = blocks_avail;
 149         fs_blocks_used = blocks_used;
 150         fs_inodes_total = ~^0;
 151         fs_inodes_reserved = ~^0;
 152         fs_inodes_avail = ~^0;
 153         fs_inodes_used = ~^0;
 154       } in
 155
 156       attach_private_data fs fat;
 157       fs
 158
 159   | { _ } -> raise Not_found            (* Not FAT32 *)
 160
 161 (* Find amount of free space by reading the FAT. *)
 162 and parse_fat_freespace fat =
 163   let used = ref ~^0 and free = ref ~^0 in
 164   iter_fat_entries fat (
 165     fun cn ->
 166       function
 167       | Free -> free := !free +^ ~^1
 168       | _ -> used := !used +^ ~^1
 169   );
 170   (!used, !free)
 171
 172 (* Iterate over the FAT.  We ignore the first two FAT entries. *)
 173 and iter_fat_entries { fat_dev = dev; fat_sectorsize = sectorsize;
 174                        fat_reserved_sectors = start;
 175                        fat_sectors_per_fat = size } f =
 176   let cn = ref ~^0 in
 177
 178   for i = 0 to (Int63.to_int size)-1 do
 179     let sector =
 180       dev#read_bitstring ((start +^ Int63.of_int i) *^ sectorsize) sectorsize in
 181     let rec loop bits =
 182       bitmatch bits with
 183       | { e : 28 : littleendian; _ : 4; rest : -1 : bitstring } ->
 184           let e =
 185             match e with
 186             | 0 -> Free
 187             | 1 -> Reserved1
 188             | (0xffffff0|0xffffff1|0xffffff2|0xffffff3|
 189                    0xffffff4|0xffffff5|0xffffff6) as r ->
 190                 Reserved (Int63.of_int r)
 191             | 0xffffff7 -> Bad
 192             | (0xffffff8|0xffffff9|0xffffffa|0xffffffb|
 193                    0xffffffc|0xffffffd|0xffffffe|
 194                        0xfffffff) as r -> Last (Int63.of_int r)
 195             | _ -> Used (Int63.of_int e) in
 196
 197           if !cn >= ~^2 then f !cn e;
 198           cn := !cn +^ ~^1;
 199           loop rest
 200
 201         | { _ } ->
 202             if !debug then
 203               eprintf "iter_fat_entries: unknown FAT entry, ignored\n%!";
 204             ()
 205     in
 206     loop sector
 207   done
 208
 209 and offset_is_free _ _ = false
 210
 211 and callbacks =
 212   let i = ref 0 in
 213   fun () -> {
 214     fs_cb_uq = (incr i; !i);
 215     fs_cb_name = id;
 216     fs_cb_printable_name = "DOS/Windows";
 217     fs_cb_offset_is_free = offset_is_free;
 218   }
 219
 220 (* Register the plugin. *)
 221 let () = register_plugin ~filesystem:probe id