package qcow
Parameters
module B : Qcow_s.RESIZABLE_BLOCK
module Time : Mirage_time_lwt.S
Signature
include Mirage_block_lwt.S
val pp_error : error Fmt.t
val pp_write_error : write_error Fmt.t
val read :
t ->
int64 ->
page_aligned_buffer list ->
(unit, error) Pervasives.result io
val write :
t ->
int64 ->
page_aligned_buffer list ->
(unit, write_error) Pervasives.result io
module Config : sig ... end
module Stats : sig ... end
val create :
B.t ->
size:int64 ->
?lazy_refcounts:bool ->
?cluster_bits:int ->
?config:Config.t ->
unit ->
(t, write_error) Pervasives.result io
create block ~size ?lazy_refcounts ?cluster_bits ?config ()
initialises a qcow-formatted image on block
with virtual size size
in bytes.
By default the file will use lazy refcounts, but this can be overriden by supplying ~lazy_refcounts:false
. By default the file will use 64KiB clusters (= 16 bits) but this can be overridden by supplying ?cluster_bits
. Note the cluster size must be greater than the sector size on the underlying block device.
The ?config
argument does not affect the on-disk format but rather the behaviour as seen from this client.
connect ?config block
connects to an existing qcow-formatted image on block
.
val resize :
t ->
new_size:int64 ->
?ignore_data_loss:bool ->
unit ->
(unit, write_error) Pervasives.result io
resize block new_size_bytes ?ignore_data_loss
changes the size of the qcow-formatted image to new_size_bytes
, rounded up to the next allocation unit. This function will fail with an error if the new size would be smaller than the old size as this would cause data loss, unless the argument ?ignore_data_loss
is set to true.
type compact_result = {
copied : int64;
(*number of sectors copied
*)refs_updated : int64;
(*number of cluster references updated
*)old_size : int64;
(*previous size in sectors
*)new_size : int64;
(*new size in sectors
*)
}
Summary of the compaction run
val compact :
t ->
?progress_cb:(percent:int -> unit) ->
unit ->
(compact_result, write_error) Pervasives.result io
compact t ()
scans the disk for unused space and attempts to fill it and shrink the file. This is useful if the underlying block device doesn't support discard and we must emulate it.
val discard :
t ->
sector:int64 ->
n:int64 ->
unit ->
(unit, write_error) Pervasives.result io
discard sector n
signals that the n
sectors starting at sector
are no longer needed and the contents may be discarded. Note the contents may not actually be deleted: this is not a "secure erase".
seek_unmapped t start
returns the offset of the next "hole": a region of the device which is guaranteed to be full of zeroes (typically guaranteed because it is unmapped)
seek_mapped t start
returns the offset of the next region of the device which may have data in it (typically this is the next mapped region)
val rebuild_refcount_table : t -> (unit, write_error) Pervasives.result io
rebuild_refcount_table t
rebuilds the refcount table from scratch. Normally we won't update the refcount table live, for performance.
val check :
B.t ->
(check_result,
[ Mirage_block.error
| `Reference_outside_file of int64 * int64
| `Duplicate_reference of (int64 * int) * (int64 * int) * int64
| `Msg of string ])
Pervasives.result
io
check t
performs sanity checks of the file, looking for errors. The error `Reference_outside_file (src, dst)
means that at offset src
there is a reference to offset dst
which is outside the file. The error `Duplicate_reference (ref1, ref2, target) means that references
at both [ref1] and [ref2] both point to the same [target] offset.
val flush : t -> (unit, write_error) Pervasives.result io
flush t
flushes any outstanding buffered writes
module Debug : sig ... end