package qcow

You can search for identifiers within the package.

in-package search v0.2.0

qcow
- Qcow
  - Make
    
    B
    
    Config
    
    Debug
    
    Setting
    
    Stats
- Qcow_bitmap
  - Interval
  - Test
- Qcow_block_cache
  - Make
    
    B
- Qcow_cache
  - Debug
- Qcow_cluster_map
  - Available
  - Copies
  - Debug
  - Erased
  - Junk
  - Move
  - MutableSet
  - Roots
- Qcow_config
- Qcow_cstructs
  - BE
- Qcow_debug
- Qcow_diet
  - ELT
  - Make
    
    Elt
    
    Interval
  - Test
- Qcow_error
  - Lwt_error
    
    Infix
    
    List
  - Lwt_write_error
    
    Infix
- Qcow_header
- Qcow_int
  - IntervalSet
    
    Interval
- Qcow_int64
  - IntervalSet
    
    Interval
- Qcow_locks
  - Client
  - Debug
  - Read
  - Write
- Qcow_metadata
  - Physical
  - Refcounts
- Qcow_padded
  - Make
    
    B
- Qcow_physical
- Qcow_recycler
  - Make
    
    B
- Qcow_rwlock
  - Client
  - Debug
  - Read
  - Write
- Qcow_s
  - INTERVAL_SET
    
    Interval
  - LOG
  - NUM
  - PRINTABLE
  - RESIZABLE_BLOCK
  - SERIALISABLE
- Qcow_types
  - Cluster
    
    IntervalSet
    
    Interval
  - Int
    
    IntervalSet
    
    Interval
  - Int16
  - Int32
  - Int64
    
    IntervalSet
    
    Interval
  - Int8
- Qcow_virtual
- Qcow_word_size
  - Cluster
    
    IntervalSet
    
    Interval

Legend:
Library
Module
Module type
Parameter
Class
Class type

module Version : sig ... end

module CryptMethod : sig ... end

module Feature : sig ... end

type offset = int64

Offset within the image

type extension = [

| `Unknown of int32 * string
| `Backing_file of string
| `Feature_name_table of Feature.t list

]

val sexp_of_extension : extension -> Sexplib0.Sexp.t

val extension_of_sexp : Sexplib0.Sexp.t -> extension

val __extension_of_sexp__ : Sexplib0.Sexp.t -> extension

type additional = {

dirty : bool;
corrupt : bool;
lazy_refcounts : bool;
autoclear_features : int64;
refcount_order : int32;

}

Version 3 and above have additional header fields

val sexp_of_additional : additional -> Sexplib0.Sexp.t

val additional_of_sexp : Sexplib0.Sexp.t -> additional

type t = {

version : Version.t;
backing_file_offset : offset;
(*
offset of the backing file path
*)
backing_file_size : int32;
(*
length of the backing file path
*)
cluster_bits : int32;
(*
a cluster is 2 ** cluster_bits in size
*)
size : int64;
(*
virtual size of the image
*)
crypt_method : CryptMethod.t;
l1_size : int32;
(*
number of 8-byte entries in the L1 table
*)
l1_table_offset : Qcow_physical.t;
(*
offset of the L1 table
*)
refcount_table_offset : Qcow_physical.t;
(*
offset of the refcount table
*)
refcount_table_clusters : int32;
(*
size of the refcount table in clusters
*)
nb_snapshots : int32;
(*
the number of internal snapshots
*)
snapshots_offset : offset;
(*
offset of the snapshot header
*)
additional : additional option;
(*
for version 3 or higher
*)
extensions : extension list;
(*
for version 3 or higher
*)

}

The qcow2 header

include Sexplib0.Sexpable.S with type t := t

val t_of_sexp : Sexplib0__.Sexp.t -> t

val sexp_of_t : t -> Sexplib0__.Sexp.t

val refcounts_per_cluster : t -> int64

The number of 16-bit reference counts per cluster

val max_refcount_table_size : t -> int64

Compute the maximum size of the refcount table

val l2_tables_required : cluster_bits:int -> int64 -> int64

Compute the number of L2 tables required for this size of image

include Qcow_s.SERIALISABLE with type t := t

val sizeof : t -> int

The size of a buffer needed to hold t

val read : Cstruct.t -> (t * Cstruct.t, [ `Msg of string ]) Stdlib.result

Read a t from the given buffer and return it, along with the unused remainder of the buffer. If the buffer cannot be parsed then return an error.

val write : t -> Cstruct.t -> (Cstruct.t, [ `Msg of string ]) Stdlib.result

Write a t into the given buffer. If the buffer is too small, then return an error. Return the unused remainder of the buffer.

include Qcow_s.PRINTABLE with type t := t

val to_string : t -> string

Produce a pretty human-readable string from a value

include Stdlib.Set.OrderedType with type t := t

val compare : t -> t -> int