qcow_image.hpp

#if !defined(__QCOW_IMAGE_HPP__)
#define __QCOW_IMAGE_HPP__

//
// local includes
//
#include "block_driver.hpp"

/*
 * The QCOW image format is one of the disk image formats supported by the QEMU processor emulator.
 * It is a representation of a fixed size block device in a file. Benefits it offers over using
 * raw dump representation include:
 *
 *   1. Smaller file size, even on filesystems which don't support holes (i.e. sparse files).
 *   2. Snapshot support, where the image only represents changes made to an underlying disk image.
 *   3. Optional zlib based compression.
 *   4. Optional AES encryption.
 */
struct qcow_image_header
{
    //
    // The first 4 bytes contain the characters 'Q', 'F', 'I' followed by 0xfb
    //
    be_uint32_t magic;

    //
    // The next 4 bytes contain the format version used by the file.
    // Currently, there has only been a single version of the format, version 1.
    //
    be_uint32_t version;

    //
    // The backing_file_offset field gives the offset from the beginning of the file to a string
    // containing the path to a file; backing_file_size gives the length of this string, which
    // isn't nul-terminated. If this image is a snapshot image, then this will be the path to
    // the original file.
    //
    be_uint64_t backing_file_offset;
    be_uint32_t backing_file_size;

    //
    // The mtime field can be ignored.
    //
    be_uint32_t mtime;

    //
    // The next 8 bytes contain the size, in bytes, of the block device represented by the image.
    //
    be_uint64_t size;

    //
    // The cluster_bits and l2_bits fields, between them, describe how to map an image offset
    // address to a location within the file. The cluster_bits field determines the number of
    // lower bits of the offset address are used as an index within a cluster; the l2_bits
    // field gives the number of bits used as an index withing the L2 table.
    //
    uint8_t cluster_bits;
    uint8_t l2_bits;

    //
    // The crypt_method field is 0 if no encryption has been used,
    // and 1 if AES encryption has been used.
    //
    be_uint32_t crypt_method;

    //
    // The l1_table_offset gives the offset within the file of the L1 table.
    //
    be_uint64_t l1_table_offset;
};

struct qcow_image : public block_driver
{
    //
    // ... to be implemented ...
    // ... file size may grow. how to handle that in an L4 dataspace? ...
    //
};

#endif

// ***** end of source ***** //