lib/diskimage_impl.mli

   1 (* (C) Copyright 2007-2008 Richard W.M. Jones, Red Hat Inc.
   2    http://libvirt.org/
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  *)
  18
  19 (* Don't use the functions and types in here directly.  The safe ones
  20  * are reexported through the Diskimage module, see diskimage.mli.
  21  *)
  22
  23 (**/**)
  24
  25 val debug : bool ref
  26
  27 (** {2 Device model} *)
  28
  29 class virtual device :
  30   object
  31     method virtual name : string
  32     method virtual size : Int63.t
  33     method read : Int63.t -> Int63.t -> string
  34     method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
  35     method virtual blocksize : Int63.t
  36     method virtual map_block : Int63.t -> (device * Int63.t) list
  37     method virtual contiguous : Int63.t -> Int63.t
  38   end
  39
  40 class block_device : string -> Int63.t ->
  41   object
  42     method name : string
  43     method size : Int63.t
  44     method read : Int63.t -> Int63.t -> string
  45     method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
  46     method blocksize : Int63.t
  47     method map_block : Int63.t -> (device * Int63.t) list
  48     method contiguous : Int63.t -> Int63.t
  49     method close : unit -> unit
  50   end
  51
  52 class offset_device : string -> Int63.t -> Int63.t -> Int63.t -> device ->
  53   object
  54     method name : string
  55     method size : Int63.t
  56     method read : Int63.t -> Int63.t -> string
  57     method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
  58     method blocksize : Int63.t
  59     method map_block : Int63.t -> (device * Int63.t) list
  60     method contiguous : Int63.t -> Int63.t
  61   end
  62
  63 class blocksize_overlay : Int63.t -> device ->
  64   object
  65     method name : string
  66     method size : Int63.t
  67     method read : Int63.t -> Int63.t -> string
  68     method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
  69     method blocksize : Int63.t
  70     method map_block : Int63.t -> (device * Int63.t) list
  71     method contiguous : Int63.t -> Int63.t
  72   end
  73
  74 val null_device : device
  75
  76 type machine = {
  77   m_name : string;
  78   m_disks : disk list;
  79   m_lv_filesystems :
  80     (lv * filesystem) list;
  81 }
  82
  83 and disk = {
  84   d_name : string;
  85   d_dev : block_device;
  86   d_content : disk_content;
  87 }
  88
  89 and disk_content =
  90     [ `Filesystem of filesystem
  91     | `Partitions of partitions
  92     | `PhysicalVolume of pv
  93     | `Unknown
  94     ]
  95
  96 and partitions = {
  97   parts_cb : partitioner_callbacks;
  98   parts_dev : device;
  99   parts : partition list;
 100 }
 101 and partition = {
 102   part_status : partition_status;
 103   part_type : int;
 104   part_dev : device;
 105   part_content : partition_content;
 106 }
 107
 108 and partition_status = Bootable | Nonbootable | Malformed | NullEntry
 109 and partition_content =
 110     [ `Filesystem of filesystem
 111     | `PhysicalVolume of pv
 112     | `Unknown
 113     ]
 114
 115 and filesystem = {
 116   fs_cb : filesystem_callbacks;
 117   fs_dev : device;
 118   fs_blocksize : Int63.t;
 119   fs_blocks_total : Int63.t;
 120   fs_is_swap : bool;
 121   fs_blocks_reserved : Int63.t;
 122   fs_blocks_avail : Int63.t;
 123   fs_blocks_used : Int63.t;
 124   fs_inodes_total : Int63.t;
 125   fs_inodes_reserved : Int63.t;
 126   fs_inodes_avail : Int63.t;
 127   fs_inodes_used : Int63.t;
 128 }
 129
 130 and pv = {
 131   pv_cb : lvm_callbacks;
 132   pv_dev : device;
 133   pv_uuid : string;
 134 }
 135 and lv = {
 136   lv_dev : device;
 137 }
 138
 139 (** {2 Table of callbacks from each type of plug-in} *)
 140
 141 and partitioner_probe = device -> partitions
 142
 143 and partitioner_callbacks = {
 144   parts_cb_name : string;
 145   parts_cb_offset_is_free : partitions -> Int63.t -> bool;
 146 }
 147
 148 and filesystem_probe = device -> filesystem
 149
 150 and filesystem_callbacks = {
 151   fs_cb_name : string;
 152   fs_cb_printable_name : string;
 153   fs_cb_offset_is_free : filesystem -> Int63.t -> bool;
 154 }
 155
 156 and lvm_probe = device -> pv
 157
 158 and lvm_callbacks = {
 159   lvm_cb_name : string;
 160   lvm_cb_list_lvs : pv list -> lv list;
 161   lvm_cb_offset_is_free : pv -> Int63.t -> bool;
 162 }
 163
 164 val name_of_filesystem : filesystem -> string
 165
 166 (** {3 Plug-in registration} *)
 167
 168 val register_plugin :
 169   ?partitioner:partitioner_probe ->
 170   ?filesystem:filesystem_probe ->
 171   ?lvm:lvm_probe ->
 172   string -> unit
 173
 174 (** {3 Plug-in-specific data management. *)
 175
 176
 177
 178
 179
 180 (** {2 Internal functions used by the plug-ins} *)
 181
 182 val canonical_uuid : string -> string
 183   (** Convert a UUID which may contain '-' characters to canonical form. *)
 184
 185 val group_by : ?cmp:('a -> 'a -> int) -> ('a * 'b) list -> ('a * 'b list) list
 186 (** Group a sorted list of pairs by the first element of the pair. *)
 187
 188 val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a list -> 'a list
 189 (** [sort_uniq xs] returns the list [xs], sorted and with all duplicate
 190     elements removed. *)
 191
 192 val uniq : ?cmp:('a -> 'a -> int) -> 'a list -> 'a list
 193 (** [uniq xs] removes adjacent duplicate elements from a list, like
 194     the Unix uniq(1) command. *)
 195
 196 val range : int -> int -> int list
 197 (** [range a b] returns the list of integers [a <= i < b].
 198     If [a >= b] then the empty list is returned.
 199 *)
 200
 201 (** {2 Functions} *)
 202
 203 val open_machine : string -> (string * string) list -> machine
 204 val close_machine : machine -> unit
 205 val scan_machine : machine -> machine
 206
 207 type ownership
 208
 209 val create_ownership : machine -> ownership
 210
 211 type owner =
 212     [ `Filesystem of filesystem
 213     | `Partitions of partitions
 214     | `PhysicalVolume of pv ]
 215
 216 val get_owners_lookup : machine -> ownership -> block_device ->
 217   (Int63.t -> (owner * Int63.t) list)
 218 val offset_is_free : (owner * Int63.t) list -> bool