Convert everything to use int63 type throughout.

[virt-df.git] / lib / diskimage.mli

diff --git a/lib/diskimage.mli b/lib/diskimage.mli
index 5711630..9247551 100644 (file)
--- a/lib/diskimage.mli
+++ b/lib/diskimage.mli
@@ -34,24 +34,24 @@ class virtual device :
   object
     method virtual name : string
       (** Return some printable name for the device. *)
-    method virtual size : int64
+    method virtual size : Int63.t
       (** Return the size of the device in bytes.
 
          Note: For some types of devices, the device may have
          "holes", alignment requirements, etc. so this method doesn't
          imply that every byte from [0..size-1] is readable. *)
-    method read : int64 -> int -> string
+    method read : Int63.t -> Int63.t -> string
       (** [read offset len] reads len bytes starting at offset.
 
          Note: A default implementation is provided for [read],
          but it is fairly inefficient because it uses {!mapblock} to
          map each block in the request. *)
-    method read_bitstring : int64 -> int -> Bitmatch.bitstring
+    method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
       (** [read_bitstring] is the same as [read] but returns
          a pa_bitmatch-style bitstring. *)
-    method virtual blocksize : int
+    method virtual blocksize : Int63.t
       (** [blocksize] returns the natural block size of the device. *)
-    method virtual mapblock : int64 -> (device * int64) list
+    method virtual mapblock : Int63.t -> (device * Int63.t) list
       (** [mapblock] describes how a block in this device is
          mapped down to any underlying device(s).
 
@@ -72,14 +72,14 @@ class virtual device :
      Note this very rare use of OOP in OCaml!
   *)
 
-class block_device : string -> int ->
+class block_device : string -> Int63.t ->
   object
     method name : string
-    method size : int64
-    method read : int64 -> int -> string
-    method read_bitstring : int64 -> int -> Bitmatch.bitstring
-    method blocksize : int
-    method mapblock : int64 -> (device * int64) list
+    method size : Int63.t
+    method read : Int63.t -> Int63.t -> string
+    method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
+    method blocksize : Int63.t
+    method mapblock : Int63.t -> (device * Int63.t) list
     method close : unit -> unit
       (** Close the device, freeing up the file descriptor. *)
   end
@@ -89,14 +89,14 @@ class block_device : string -> int ->
        where [filename] is the path to the file or device and
        [blocksize] is the blocksize of the device. *)
 
-class offset_device : string -> int64 -> int64 -> int -> device ->
+class offset_device : string -> Int63.t -> Int63.t -> Int63.t -> device ->
   object
     method name : string
-    method size : int64
-    method read : int64 -> int -> string
-    method read_bitstring : int64 -> int -> Bitmatch.bitstring
-    method blocksize : int
-    method mapblock : int64 -> (device * int64) list
+    method size : Int63.t
+    method read : Int63.t -> Int63.t -> string
+    method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
+    method blocksize : Int63.t
+    method mapblock : Int63.t -> (device * Int63.t) list
   end
     (** A concrete device which maps a linear part of an underlying device.
 
@@ -108,6 +108,17 @@ class offset_device : string -> int64 -> int64 -> int -> device ->
        Useful for things like partitions.
     *)
 
+class blocksize_overlay : Int63.t -> device ->
+  object
+    method name : string
+    method size : Int63.t
+    method read : Int63.t -> Int63.t -> string
+    method read_bitstring : Int63.t -> Int63.t -> Bitmatch.bitstring
+    method blocksize : Int63.t
+    method mapblock : Int63.t -> (device * Int63.t) list
+  end
+    (** Change the blocksize of an existing device. *)
+
 val null_device : device
     (** The null device.  Any attempt to read generates an error. *)
 
@@ -195,16 +206,17 @@ and partition_content =
 
 and filesystem = {
   fs_plugin_id : fs_plugin_id;         (** Filesystem type. *)
-  fs_block_size : int64;               (** Block size (bytes). *)
-  fs_blocks_total : int64;             (** Total blocks. *)
+  fs_dev : device;                     (** Device containing the filesystem. *)
+  fs_blocksize : Int63.t;              (** Block size (bytes). *)
+  fs_blocks_total : Int63.t;           (** Total blocks. *)
   fs_is_swap : bool;                   (** If swap, following not valid. *)
-  fs_blocks_reserved : int64;          (** Blocks reserved for super-user. *)
-  fs_blocks_avail : int64;             (** Blocks free (available). *)
-  fs_blocks_used : int64;              (** Blocks in use. *)
-  fs_inodes_total : int64;             (** Total inodes. *)
-  fs_inodes_reserved : int64;          (** Inodes reserved for super-user. *)
-  fs_inodes_avail : int64;             (** Inodes free (available). *)
-  fs_inodes_used : int64;              (** Inodes in use. *)
+  fs_blocks_reserved : Int63.t;                (** Blocks reserved for super-user. *)
+  fs_blocks_avail : Int63.t;           (** Blocks free (available). *)
+  fs_blocks_used : Int63.t;            (** Blocks in use. *)
+  fs_inodes_total : Int63.t;           (** Total inodes. *)
+  fs_inodes_reserved : Int63.t;                (** Inodes reserved for super-user. *)
+  fs_inodes_avail : Int63.t;           (** Inodes free (available). *)
+  fs_inodes_used : Int63.t;            (** Inodes in use. *)
 }
     (** A filesystem, with superblock contents. *)