/* 
 * This file is part of the Palacios Virtual Machine Monitor developed
 * by the V3VEE Project with funding from the United States National 
 * Science Foundation and the Department of Energy.  
 *
 * The V3VEE Project is a joint project between Northwestern University
 * and the University of New Mexico.  You can find out more at 
 * http://www.v3vee.org
 *
 * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org> 
 * All rights reserved.
 *
 * Author: Yang Yang	<geraint0923@gmail.com>
 *         Weixiao Fu	<weixiaofu2014@u.northwestern.edu>
 *
 * This is free software.  You are permitted to use,
 * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
 */

#include <palacios/vmm.h>
#include <palacios/vmm_dev_mgr.h>

#include <interfaces/vmm_file.h>
#include <palacios/vm_guest.h>

#ifndef V3_CONFIG_DEBUG_QCOWDISK
#undef PrintDebug
#define PrintDebug(fmt, args...)
#endif

#define V3_PACKED __attribute__((packed))
#define QCOW2_MAGIC		(('Q'<<24) | ('F'<<16) | ('I'<<8) | (0xfb))

#define QCOW2_COPIED		(1ULL<<63)
#define QCOW2_COMPRESSED	(1ULL<<62)
#define INIT_BUFF_SIZE	(512)

#define ERROR(...) PrintError(VM_NONE,VCORE_NONE,"qcow2: " __VA_ARGS__)
#define DEBUG(...) PrintDebug(VM_NONE,VCORE_NONE,"qcow2: " __VA_ARGS__)
#define INFO(...) V3_Print(VM_NONE,VCORE_NONE,"qcow2: " __VA_ARGS__)


// the header structure for QCOW2
typedef struct v3_qcow2_header {
  uint32_t magic;
  uint32_t version;
  
  uint64_t backing_file_offset;
  uint32_t backing_file_size;
	
  uint32_t cluster_bits;
  uint64_t size;
  
  uint32_t crypt_method;
  
  uint32_t l1_size;
  uint64_t l1_table_offset;
  
  uint64_t refcount_table_offset;
  uint32_t refcount_table_clusters;
  
  uint32_t nb_snapshots;
  uint64_t snapshots_offset;
  
} V3_PACKED v3_qcow2_header_t;

// the header structure for each QCOW2 snapshot
typedef struct v3_qcow2_snapshot_header {
  uint64_t l1_table_offset;
  uint32_t l1_size;

  uint16_t id_str_size;
  uint16_t name_size;
  
  uint32_t date_sec;
  uint32_t date_nsec;
  
  uint64_t vm_clock_nsec;
  uint32_t vm_state_size;
  uint32_t extra_data_size;
} V3_PACKED v3_qcow2_snapshot_header_t;

// the private structure used by QCOW2 implementation
typedef struct v3_qcow2 {
  v3_file_t fd;
  struct v3_qcow2 *backing_qcow2;
  char *backing_file_name;
  uint64_t cluster_size;
  uint32_t l1_bits;
  uint64_t l1_mask;
  uint32_t l2_bits;
  uint64_t l2_mask;
  uint32_t refcount_block_bits;
  uint64_t refcount_block_mask;
  uint32_t refcount_table_bits;
  uint64_t refcount_table_mask;
  uint64_t free_cluster_index;
  v3_qcow2_header_t header;
} v3_qcow2_t;

typedef struct v3_qcow2_table_entry {
  uint64_t offset: 62;
  uint8_t compressed: 1;
  uint8_t copied: 1;
} v3_qcow2_table_entry_t;


// our implementations for Big/Little Endian conversion
static inline uint16_t be16toh(uint16_t v) 
{
  return ((v&0xff)<<8) | ((v&0xff00)>>8);
}

static inline uint32_t be32toh(uint32_t v) 
{
  return (((uint32_t)be16toh(v&0x0000ffffU))<<16) | (uint32_t)be16toh((v&0xffff0000U)>>16); 
}

static inline uint64_t be64toh(uint64_t v) 
{
  return (((uint64_t)be32toh(v&0x00000000ffffffffU))<<32) | (uint64_t)be32toh((v&0xffffffff00000000U)>>32);
}

static inline uint16_t htobe16(uint16_t v) 
{
  return be16toh(v);
}

static inline uint64_t htobe64(uint64_t v) 
{
  return be64toh(v);
}

uint64_t v3_qcow2_get_capacity(v3_qcow2_t *pf) 
{
  return pf ? pf->header.size : 0;
}

static inline uint64_t v3_qcow2_get_cluster_index(v3_qcow2_t *pf, uint64_t file_pos) 
{
  if (!pf) {
    return 0;
  }
  return file_pos >> pf->header.cluster_bits;
}

static int v3_qcow2_get_refcount(v3_qcow2_t *pf, uint64_t idx) 
{
  int res = -1, ret = 0;
  uint16_t val = 0;
  uint64_t table_idx = 0, block_idx = 0, block_offset = 0;

  if (!pf) {
    return res;
  }

  block_idx = idx & pf->refcount_block_mask;
  idx >>= pf->refcount_block_bits;
  table_idx = idx & pf->refcount_table_mask;
  
  ret = v3_file_read(pf->fd, (uint8_t*)&block_offset, sizeof(uint64_t), pf->header.refcount_table_offset + table_idx * sizeof(uint64_t));
  
  // FIXME: how to deal with the wrong position
  if (ret != sizeof(uint64_t)) {
    ERROR("read failed\n");
    return 0;
  }

  block_offset = be64toh(block_offset);

  // if cluster is not yet allocated, return 0
  if (!block_offset) {
    return 0;
  }
  
  ret = v3_file_read(pf->fd, (uint8_t*)&val, sizeof(uint16_t), block_offset + block_idx * sizeof(uint16_t));
  
  if (ret != sizeof(uint16_t)) {
    ERROR("read failed\n");
    return 0;
  }
  
  val = be16toh(val);
  
  return val;
}

/*
 * this function is a wrapper of v3_qcow2_get_refcount
 * takes file offset and returns the reference count
 * it is commented to avoid compile warning
 *
 */
__attribute__((unused))
static int v3_qcow2_get_refcount_by_file_position(v3_qcow2_t *pf, uint64_t file_pos) 
{
  int res = -1;
  uint64_t idx = 0;

  if (!pf) {
    return res;
  }
  idx = v3_qcow2_get_cluster_index(pf, file_pos);

  return v3_qcow2_get_refcount(pf, idx);
}


/*
 * to allocate the contiguous clusters
 * return the cluster index in the QCOW2 file
 * return positive if successfully, otherwise zero(0)
 */
static uint64_t v3_qcow2_alloc_clusters(v3_qcow2_t *pf, uint32_t nb_clusters) 
{
  uint32_t i;
  int refcount = 0;
  uint64_t idx = 0, ret_idx = 0;
  
  if(!nb_clusters) {
    return 0;
  }
	
  if(!pf) {
    return 0;
  }

  /*
   * referenced the algorithm from Qemu
   */
 retry:
  ret_idx = pf->free_cluster_index;
  for (i = 0; i < nb_clusters; i++) {
    idx = pf->free_cluster_index++;
    refcount = v3_qcow2_get_refcount(pf, idx);
    if(refcount < 0) {
      return 0;
    } else if(refcount) {
      goto retry;
    }
  }
  return ret_idx;
}

static int v3_qcow2_addr_split(v3_qcow2_t *qc2, uint64_t addr, uint64_t *l1_idx, uint64_t *l2_idx, uint64_t *offset) 
{
  if (!qc2 || !l1_idx || !l2_idx || !offset) {
    return -1;
  }
	
  *offset = addr & (qc2->cluster_size - 1);
  addr = addr >> qc2->header.cluster_bits;
  *l2_idx = addr & qc2->l2_mask;
  addr = addr >> qc2->l2_bits;
  *l1_idx = addr * qc2->l1_mask;

  return 0;
}

static v3_qcow2_t *v3_qcow2_open(struct v3_vm_info* vm, char *path, int flags) 
{
  int ret = 0;
  if(!path) {
    return NULL;
  }
	
  v3_qcow2_t *res = (v3_qcow2_t*)V3_Malloc(sizeof(v3_qcow2_t));

  if (!res) {
    ERROR("failed to allocate\n");
    goto failed;
  }
   
  memset(res, 0, sizeof(v3_qcow2_t));
  
  res->fd = v3_file_open(vm, path, flags);
	
  if (res->fd < 0) {
    ERROR("failed to open underlying file\n");
    goto clean_mem;
  }

  ret = v3_file_read(res->fd, (uint8_t*)&res->header, sizeof(res->header), 0);

  if (ret != sizeof(res->header)) {
    ERROR("failed to read header\n");
    goto clean_mem;
  }
  
  res->header.magic = be32toh(res->header.magic);
  
  if (res->header.magic != QCOW2_MAGIC) {
    ERROR("wrong magic in header\n");
    goto clean_file;
  } 
#ifdef __DEBUG__
  else {
    DEBUG("right magic\n");
  }
#endif

  res->header.version = be32toh(res->header.version);

  if (res->header.version < 2) {
    ERROR("unsupported version: %d\n", res->header.version);
    goto clean_file;
  }
#ifdef __DEBUG__
  else {
    DEBUG("supported version: %d\n", res->header.version);
  }
#endif

  res->header.backing_file_offset = be64toh(res->header.backing_file_offset);
  res->header.backing_file_size = be32toh(res->header.backing_file_size);

  if (res->header.backing_file_size) {
#ifdef __DEBUG__
    DEBUG("backing file size is larger than zero: %d\n", res->header.backing_file_size);
#endif

    res->backing_file_name = (char*)V3_Malloc(res->header.backing_file_size + 1);

    if (!res->backing_file_name) {
      ERROR("failed to allocate memory for backing file name\n");
      goto clean_file;
    }

    res->backing_file_name[res->header.backing_file_size] = 0;

    ret = v3_file_read(res->fd, (void*)res->backing_file_name, res->header.backing_file_size, res->header.backing_file_offset);

    if(ret != res->header.backing_file_size) {
      ERROR("failed to read backing file name from %s\n", path);
      V3_Free(res->backing_file_name);
      goto clean_file;
    }

    res->backing_qcow2 = v3_qcow2_open(vm, res->backing_file_name, flags);

    if(res->backing_qcow2) {
      DEBUG("load backing file successfully\n");
    } else {
      ERROR("failed to load backing file, exit\n");
      return NULL;
    }
    
    DEBUG("successfully read the backing file name: %s\n", res->backing_file_name);

  } else {
    // no backing file

    res->backing_qcow2 = NULL;

    DEBUG("read no backing file name since size == %d\n", res->header.backing_file_size);

  }
  
  res->header.cluster_bits = be32toh(res->header.cluster_bits);
  res->cluster_size = 1 << res->header.cluster_bits;
  res->l2_bits = res->header.cluster_bits - 3;
  res->l2_mask = (((uint64_t)1)<<res->l2_bits) - 1;
  res->l1_bits = sizeof(uint64_t) * 8 - res->l2_bits - res->header.cluster_bits;
  res->l1_mask = (((uint64_t)1)<<res->l1_bits) - 1;
  
  DEBUG("cluster_bits: %d\n", res->header.cluster_bits);
  
  res->header.size = be64toh(res->header.size);
  
  DEBUG("size: %llu\n", res->header.size);
  
  res->header.crypt_method = be32toh(res->header.crypt_method);
  
  if (res->header.crypt_method) {
    DEBUG("AES encryption\n");
  } else {
    DEBUG("no encryption\n");
  }
  
  res->header.l1_size = be32toh(res->header.l1_size);
  res->header.l1_table_offset = be64toh(res->header.l1_table_offset);
  
  res->header.refcount_table_offset = be64toh(res->header.refcount_table_offset);
  res->header.refcount_table_clusters = be32toh(res->header.refcount_table_clusters);
  
  res->refcount_block_bits = res->header.cluster_bits - 1;
  res->refcount_block_mask = (1LL<<res->refcount_block_bits) - 1;
  res->refcount_table_bits = 8 * sizeof(uint64_t) - res->refcount_block_bits;
  res->refcount_table_mask = (1LL<<res->refcount_table_bits) - 1;
  
  res->header.nb_snapshots = be32toh(res->header.nb_snapshots);
  res->header.snapshots_offset = be64toh(res->header.snapshots_offset);
  
  
  DEBUG("l1 size: %d\n", res->header.l1_size);
  DEBUG("l1 table offset: %llu\n", res->header.l1_table_offset);
  
  DEBUG("refcount_table_offset: %llu\n", res->header.refcount_table_offset);
  DEBUG("refcount_table_clusters: %d\n", res->header.refcount_table_clusters);
  
  DEBUG("nb_snapshots: %d\n", res->header.nb_snapshots);
  DEBUG("snapshots_offset: %llu\n", res->header.snapshots_offset);
  
  res->free_cluster_index = 1;
  
  // TODO: initialize the free cluster index to a reasonable value
  while (1) {
    if (v3_qcow2_get_refcount(res, res->free_cluster_index)) {
      res->free_cluster_index++;
    } else {
      break;
    }
  }
  
  
  return res;
  
clean_file:
  v3_file_close(res->fd);
clean_mem:
  V3_Free(res);
failed:
  return NULL;
}

static void v3_qcow2_close(v3_qcow2_t *pf) 
{
  if(!pf) {
    return;
  }

  v3_file_close(pf->fd);

  if (pf->backing_file_name) {
    V3_Free(pf->backing_file_name);
  }

  if (pf->backing_qcow2) {
    v3_qcow2_close(pf->backing_qcow2);
  }

  V3_Free(pf);
}

static uint64_t v3_qcow2_get_cluster_offset(v3_qcow2_t *qc, uint64_t l1_idx, uint64_t l2_idx, uint64_t offset) 
{
  uint64_t res = 0;
  uint64_t l1_val = 0, l2_val = 0;
  v3_qcow2_table_entry_t *ent = NULL;
  int ret = 0;

  if (!qc) {
    goto done;
  }

  if (l1_idx >= qc->header.l1_size) {
    return 0ULL;
  }

  ret = v3_file_read(qc->fd, (void*)&l1_val, sizeof(uint64_t), l1_idx * sizeof(uint64_t) + qc->header.l1_table_offset);

  if (ret != sizeof(uint64_t)) {
    ERROR("Failed to read L1\n");
    goto done;
  }

  l1_val = be64toh(l1_val);
  ent = (v3_qcow2_table_entry_t*)&l1_val;

  if (!ent->offset) {
    goto done;
  }
	
  ret = v3_file_read(qc->fd, (void*)&l2_val, sizeof(uint64_t), l2_idx * sizeof(uint64_t) + ent->offset);
	
  if (ret != sizeof(uint64_t)) {
    ERROR("Failed to read L2\n");
    goto done;
  }

  l2_val = be64toh(l2_val);
  ent = (v3_qcow2_table_entry_t*)&l2_val;
  res = ent->offset;

done:
  return res;
}


static int v3_qcow2_read_cluster(v3_qcow2_t *pf, uint8_t *buff, uint64_t pos, int len) 
{
  int ret = 0;
  uint64_t l1_idx = 0, l2_idx = 0, offset = 0;
  uint64_t file_offset = 0;

  if(!pf || !buff || !len) {
    return -1;
  }

  ret = v3_qcow2_addr_split(pf, pos, &l1_idx, &l2_idx, &offset);
	
  if (ret) {
    ERROR("failed to split address\n");
    return -1;
  }
  
  file_offset = v3_qcow2_get_cluster_offset(pf, l1_idx, l2_idx, offset);

  if (file_offset) {

    ret = v3_file_read(pf->fd, buff, len, file_offset + (pos & (pf->cluster_size - 1)));

    // it is possible to get a negative value because of the hole
    if (ret < 0) {
      return -1;
    }

  } else if(pf->backing_qcow2) {
    return v3_qcow2_read_cluster(pf->backing_qcow2, buff, pos, len);
  } else {
    memset(buff, 0, len);
  }

  return 0;
}

static int v3_qcow2_read(v3_qcow2_t *pf, uint8_t *buff, uint64_t pos, int len) 
{
  if(!pf || !buff || !len) {
    return -1;
  }
	
  uint64_t next_addr, cur_len;
  int ret = 0;

  while (len) {
    next_addr = (pos + pf->cluster_size) & ~(pf->cluster_size - 1);
    cur_len = next_addr - pos;
    cur_len = cur_len < len ? cur_len : len;
    //DEBUG("pos=%lu, len=%lu\n", pos, cur_len);
    ret = v3_qcow2_read_cluster(pf, buff, pos, cur_len);
    if (ret) {
      return -1;
    }
    buff += cur_len;
    pos += cur_len;
    len -= cur_len;
  }

  return 0;
}

// in this function, we assmue we must have the corresponding refcount block
// so we will not allocate the refcount block here
static int v3_qcow2_update_refcount(v3_qcow2_t *pf, uint64_t cluster_idx, int count) 
{
  uint64_t table_idx = 0, block_idx = 0, block_offset = 0, idx = cluster_idx;
  int ret = 0;
  uint16_t val = count;
  
  if (!pf) {
    return -1;
  }
	
  block_idx = idx & pf->refcount_block_mask;
  idx >>= pf->refcount_block_bits;
  table_idx = idx & pf->refcount_table_mask;
  
  ret = v3_file_read(pf->fd, (uint8_t*)&block_offset, sizeof(uint64_t), pf->header.refcount_table_offset + table_idx * sizeof(uint64_t));

  if (ret != sizeof(uint64_t) || !block_offset) {
    ERROR("something wrong with update refcount, exit\n");
    return -1;
  }

  block_offset = be64toh(block_offset);
  val = htobe16(val);
  
  ret = v3_file_write(pf->fd, (uint8_t*)&val, sizeof(uint16_t), block_offset + block_idx * sizeof(uint16_t));
  
  if (ret != sizeof(uint16_t)) {
    ERROR("write failed when update refcount, exit\n");
    return -1;
  }
  
  return 0;
}

// in this function, we need to resolve the circular dependency when the refcount itself is not allocated
// since for cluster_bits==16, it needs 65536G to use more than one cluster to contain all the refcount 
// table, we don't handle that case
// of course, we can handle this case if we have enough time
static int v3_qcow2_alloc_refcount(v3_qcow2_t *pf, uint64_t cluster_idx) 
{
  int res = -1, ret;
  uint8_t zero_buff[INIT_BUFF_SIZE];
  uint16_t val = 0;
  uint64_t idx = cluster_idx, table_idx = 0, block_idx = 0, block_offset = 0;
  uint64_t new_cluster_idx, new_table_idx = 0, new_block_idx = 0, write_value;
  uint64_t left_size, start_offset, buf_length;
	
  if (!pf) {
    return -1;
  }
	
  block_idx = idx & pf->refcount_block_mask;
  idx >>= pf->refcount_block_bits;
  table_idx = idx & pf->refcount_table_mask;

  // TODO: re-allocate larger refcount table if needed

retry:
  ret = v3_file_read(pf->fd, (uint8_t*)&block_offset, sizeof(uint64_t), pf->header.refcount_table_offset + table_idx * sizeof(uint64_t));

  if (ret != sizeof(uint64_t) || table_idx > pf->header.refcount_table_clusters) {
    ERROR("read failed, exit!\n");
    return -1;	
  }
	
  block_offset = be64toh(block_offset);
  
  if (!block_offset) {
    // allocate a cluster as a new refcount block
    // and also initialize this cluster with zeros

    new_cluster_idx = v3_qcow2_alloc_clusters(pf, 1);

    if (new_cluster_idx <= 0) {
      ERROR("failed to allocate new cluster, exit!\n");
      return -1;
    }

    idx = new_cluster_idx;
    new_block_idx = idx & pf->refcount_block_mask;
    idx >>= pf->refcount_block_bits;
    new_table_idx = idx & pf->refcount_table_mask;
    
    // initialize with zeros
    start_offset = new_cluster_idx << pf->header.cluster_bits;
    left_size = pf->cluster_size;
    memset(zero_buff, 0, INIT_BUFF_SIZE);

    while (left_size > 0) {
      
      buf_length = INIT_BUFF_SIZE < left_size ? INIT_BUFF_SIZE : left_size;
      
      ret = v3_file_write(pf->fd, zero_buff, buf_length, start_offset);
      
      if (ret != buf_length) {
	ERROR("something wrong with write, exit\n");
	return -1;
      }

      start_offset += buf_length;
      
      left_size -= buf_length;

    }

    // update the refcount table with the new refcount block

    write_value = htobe64(new_table_idx << pf->header.cluster_bits);

    ret = v3_file_write(pf->fd, (uint8_t*)&write_value, sizeof(uint64_t), pf->header.refcount_table_offset + table_idx * sizeof(uint64_t));
    
    if (ret != sizeof(uint64_t) ) {
      ERROR("write of data failed\n");
      return -1;
    }

    if (new_table_idx == table_idx) {
      // in the same refcount block, increase its refcount here
      val = htobe16(1);

      ret = v3_file_write(pf->fd, (uint8_t*)&val, sizeof(uint16_t), (new_table_idx << pf->header.cluster_bits) + sizeof(uint16_t) * new_block_idx);

      if (ret != sizeof(uint16_t)) {
	ERROR("write failed\n");
	return -1;
      }

    } else {
      v3_qcow2_alloc_refcount(pf, new_cluster_idx);
      v3_qcow2_update_refcount(pf, new_cluster_idx, 1);
    }

    goto retry;
  }

  res = 0;
  return res;
}



static int v3_qcow2_increase_refcount(v3_qcow2_t *pf, uint64_t cluster_idx) 
{
  int refcount = 0;

  if (!pf) {
    return -1;
  }

  refcount = v3_qcow2_get_refcount(pf, cluster_idx);
	
  if (refcount <= 0) {
    // execute to here means that no cluster block entry is allocated
    // we need to allocate the entry here
    refcount = v3_qcow2_alloc_refcount(pf, cluster_idx);

    if (refcount) {
      ERROR("something wrong when allocate refcount entry, exit!\n");
      return -1;
    }

    refcount = 1;	

  } else {

    refcount++;

  }

  // write the refcount back to the file
  return v3_qcow2_update_refcount(pf, cluster_idx, refcount);
}

/*
 * this function is to decrease the reference count of a cluster
 * since the snapshot is not implemented, 
 */
__attribute__ ((unused))
static int v3_qcow2_decrease_refcount(v3_qcow2_t *pf, uint64_t cluster_idx) 
{
  int refcount = 0;
  
  if (!pf) {
    return -1;
  }

  refcount = v3_qcow2_get_refcount(pf, cluster_idx);

  if(refcount <= 0) {
    ERROR("attempt to decrease the refcount for a cluster, exit\n");
    return -1;
  }

  refcount--;

  return v3_qcow2_update_refcount(pf, cluster_idx, refcount);
}


/*
 * do nothing but return if no need to allocate new cluster
 * only allocate one cluster if necessary
 */
static uint64_t v3_qcow2_alloc_cluster_offset(v3_qcow2_t *pf, uint64_t pos) 
{
  uint64_t res = 0, l1_idx = 0, l2_idx = 0, offset = 0, l2_cluster_offset, done_bytes;
  uint64_t l2_cluster_idx;
  uint64_t cluster_offset = 0;
  int ret = 0;
  uint8_t init_buff[INIT_BUFF_SIZE], *data_buff;
  
  if (!pf) {
    return res;
  }
	
  ret = v3_qcow2_addr_split(pf, pos, &l1_idx, &l2_idx, &offset);

  if (ret) {
    ERROR("cannot split address\n");
    return res;
  }
		
  // FIXME: in fact, we should check the refcount to be 1,
  // otherwise we should copy
  // do it later

  res = v3_qcow2_get_cluster_offset(pf, l1_idx, l2_idx, offset);

  if (res) {
    cluster_offset = res;
    goto done;
  }

  /*
   * need to allocate a new cluster for write
   * also need to update the l1 and l2 table
   */
	
  ret = v3_file_read(pf->fd, (uint8_t*)&l2_cluster_offset, sizeof(uint64_t),  pf->header.l1_table_offset + sizeof(uint64_t) * l1_idx);
  
  if (ret != sizeof(uint64_t)) { 
    ERROR("read failed\n");
    return res;
  }

  l2_cluster_offset = be64toh(l2_cluster_offset) & ~(QCOW2_COPIED | QCOW2_COMPRESSED);

  if (!l2_cluster_offset/*l1_idx >= pf->header.l1_size*/) { // huh?
    /*
     * need to allocate a new l1 entry
     * for simplicity, only allow 2^(cluster_bits-3) entry in l1 table
     */
	
    l2_cluster_idx = v3_qcow2_alloc_clusters(pf, 1);
    l2_cluster_offset = (l2_cluster_idx << pf->header.cluster_bits);
    
    // increase the reference count for this cluster
    v3_qcow2_increase_refcount(pf, l2_cluster_idx);

    memset(init_buff, 0, INIT_BUFF_SIZE);
	
    for (done_bytes = 0; done_bytes < pf->cluster_size; done_bytes += INIT_BUFF_SIZE) {

      ret = v3_file_write(pf->fd, init_buff, INIT_BUFF_SIZE, l2_cluster_offset + done_bytes);

      if (ret != INIT_BUFF_SIZE) {
	ERROR("write failed\n");
	return res;
      }
    }
	
    /*
     * set the copied bit
     */
    l2_cluster_offset |= QCOW2_COPIED;
    l2_cluster_offset = htobe64(l2_cluster_offset);
    
    ret = v3_file_write(pf->fd, (uint8_t*)&l2_cluster_offset, sizeof(uint64_t),  pf->header.l1_table_offset + sizeof(uint64_t) * l1_idx);
    
    if (ret != sizeof(uint64_t)) { 
      ERROR("write failed\n");
      return res;
    }
    
  }
	
  ret = v3_file_read(pf->fd, (uint8_t*)&l2_cluster_offset, sizeof(uint64_t),  pf->header.l1_table_offset + sizeof(uint64_t) * l1_idx);
    
  if (ret != sizeof(uint64_t)) {
    ERROR("read failed\n");
    return res;
  }
    
  l2_cluster_offset = be64toh(l2_cluster_offset) & ~(QCOW2_COPIED | QCOW2_COMPRESSED);
  
  /*
   * begin to retrieve cluster_offset
   */
  
  // adjust the l2_cluster_offset to the right entry address
  l2_cluster_offset += sizeof(uint64_t) * l2_idx;

  ret = v3_file_read(pf->fd, (uint8_t*)&cluster_offset, sizeof(uint64_t), l2_cluster_offset);
  
  if (ret!=sizeof(uint64_t)) { 
    ERROR("read failed\n");
    return res;
  }
  
  cluster_offset = be64toh(cluster_offset) & ~(QCOW2_COPIED | QCOW2_COMPRESSED);
  
  if (!cluster_offset) {
    /*
     * if the cluster_offset is not allocated
     */
    l2_cluster_idx = v3_qcow2_alloc_clusters(pf, 1);
    cluster_offset = (l2_cluster_idx << pf->header.cluster_bits);
    
    // TODO: initialization
    // initialize the cluster with the original data
    data_buff = (uint8_t*)V3_Malloc(pf->cluster_size);
    
    if (data_buff) {
      
      pos = (pos >> pf->header.cluster_bits) << pf->header.cluster_bits;	
      
      v3_qcow2_read_cluster(pf, data_buff, pos, pf->cluster_size);
      
      ret = v3_file_write(pf->fd, data_buff, pf->cluster_size, cluster_offset);
      
      if (ret!=pf->cluster_size) { 
	ERROR("write failed\n");
	return res;
      }
      
      V3_Free(data_buff);
      
    } else {
      
      ERROR("failed to initialize the original data\n");
      
    }
    
    offset = htobe64(cluster_offset | QCOW2_COPIED);
    
    ret = v3_file_write(pf->fd, (uint8_t*)&offset, sizeof(uint64_t), l2_cluster_offset);
    
    if (ret!=sizeof(uint64_t)) {
      ERROR("write failed\n");
      return res;
    }
    
    v3_qcow2_increase_refcount(pf, l2_cluster_idx);
    
  }
  
 done:
  return cluster_offset;
}

static int v3_qcow2_write_cluster(v3_qcow2_t *pf, uint8_t *buff, uint64_t pos, int len) 
{
  if(!pf || !buff) {
    return -1;
  }

  uint64_t cluster_addr, cluster_offset;
  int ret = 0;

  cluster_addr = v3_qcow2_alloc_cluster_offset(pf, pos);

  if (!cluster_addr) {
    ERROR("zero cluster address\n");
    return -1;
  }
  
  cluster_offset = pos & (pf->cluster_size - 1);
	
  ret = v3_file_write(pf->fd, buff, len, cluster_addr + cluster_offset);
	
  if (ret != len) {
    ERROR("write failed\n");
    return -1;
  }
  
  return 0;
}

static int v3_qcow2_write(v3_qcow2_t *pf, uint8_t *buff, uint64_t pos, int len) 
{
  if (!pf || !buff || !len) {
    return -1;
  }
	
  uint64_t next_addr, cur_len;
  int ret = 0;

  while (len) {
    next_addr = (pos + pf->cluster_size) & ~(pf->cluster_size - 1);
    cur_len = next_addr - pos;
    cur_len = cur_len < len ? cur_len : len;

    DEBUG("pos=%llu, len=%llu\n", pos, cur_len);
		
    ret = v3_qcow2_write_cluster(pf, buff, pos, cur_len);
    
    if (ret) {
      return -1;
    }
    
    buff += cur_len;
    pos += cur_len;
    len -= cur_len;
  }
	
  return ret;
}

static int read(uint8_t * buf, uint64_t lba, uint64_t num_bytes, void * private_data) 
{
  v3_qcow2_t * disk = (v3_qcow2_t *) private_data;

  DEBUG("QCOW Reading %llu bytes from %llu to 0x%p\n", num_bytes, lba, buf);

  if (lba + num_bytes > disk->header.size) {
    ERROR("Out of bounds read: lba=%llu, num_bytes=%llu, capacity=%llu\n",
	  lba, num_bytes, disk->header.size);
    return -1;
  }

  return v3_qcow2_read(disk, buf, lba, num_bytes);
}


static int write(uint8_t * buf, uint64_t lba, uint64_t num_bytes, void * private_data) 
{
  v3_qcow2_t * disk = (v3_qcow2_t *) private_data;
  
  DEBUG("QCOW Writing %llu bytes from 0x%p to %llu\n", num_bytes,  buf, lba);
  
  if (lba + num_bytes > disk->header.size) {
    ERROR("Out of bounds read: lba=%llu, num_bytes=%llu, capacity=%llu\n",
	  lba, num_bytes, disk->header.size);
    return -1;
  }

  return v3_qcow2_write(disk, buf, lba, num_bytes);
  
}


static uint64_t get_capacity(void * private_data) 
{
    v3_qcow2_t * disk = (v3_qcow2_t *)private_data;

    DEBUG("Querying QCOWDISK capacity %llu\n", v3_qcow2_get_capacity(disk));
    
    return v3_qcow2_get_capacity(disk);
}

static struct v3_dev_blk_ops blk_ops = {
    .read = read, 
    .write = write,
    .get_capacity = get_capacity,
};




static int disk_free(v3_qcow2_t * disk) 
{
    v3_qcow2_close(disk);
    return 0;
}

static struct v3_device_ops dev_ops = {
    .free = (int (*)(void *))disk_free,
};




static int disk_init(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) 
{
    v3_qcow2_t * disk = NULL;
    char * path = v3_cfg_val(cfg, "path");
    char * dev_id = v3_cfg_val(cfg, "ID");
    char * writable = v3_cfg_val(cfg, "writable");
    char * writeable = v3_cfg_val(cfg, "writeable");

    v3_cfg_tree_t * frontend_cfg = v3_cfg_subtree(cfg, "frontend");
    int flags = FILE_OPEN_MODE_READ;

    PrintDebug(vm,VCORE_NONE,"Welcome to the QCOWDISK Implementation!\n");

    if ( ((writable) && (writable[0] == '1')) ||
	 ((writeable) && (writeable[0] == '1')) ) {
	flags |= FILE_OPEN_MODE_WRITE;
    }

    if (path == NULL) {
	PrintError(vm, VCORE_NONE, "Missing path (%s) for %s\n", path, dev_id);
	return -1;
    }

    disk = v3_qcow2_open(vm, path, flags);

    if (disk == NULL) {
	PrintError(vm, VCORE_NONE, "Could not open file disk:%s\n", path);
	return -1;
    }

    struct vm_device * dev = v3_add_device(vm, dev_id, &dev_ops, disk);

    if (dev == NULL) {
	PrintError(vm, VCORE_NONE, "Could not attach device %s\n", dev_id);
	V3_Free(disk);
	return -1;
    }

    if (v3_dev_connect_blk(vm, v3_cfg_val(frontend_cfg, "tag"), 
			   &blk_ops, frontend_cfg, disk) == -1) {
	PrintError(vm, VCORE_NONE, "Could not connect %s to frontend %s\n", 
		   dev_id, v3_cfg_val(frontend_cfg, "tag"));
	v3_remove_device(dev);
	return -1;
    }
    

    return 0;
}


device_register("QCOWDISK", disk_init)