lib/diskimage_impl.mli

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