Archipelago » qemu

    (Johannes Schindelin)

version 0.7.2:

  - x86_64 fixes (Win2000 and Linux 2.6 boot in 32 bit)

  - merge self modifying code handling in dirty ram page mecanism.

  - MIPS fixes (Ralf Baechle)

  - FDC fixes for Win98

version 0.5.4:

  - qemu-fast fixes

  - BIOS area protection fix (aka EMM386.EXE fix) (Mike Nordell)

  - keyboard/mouse fix (Mike Nordell)

  - eflags optimisation fix for string operations

version 0.5.1:

  - float access fixes when using soft mmu

  - PC emulation support on PowerPC

  - A20 support

  - Major SPARC target fixes (dynamically linked programs begin to work)

version 0.5.0:

  - full hardware level VGA emulation

  - graphical display with SDL

  - added PS/2 mouse and keyboard emulation

 - SMP kernels can at least be booted

version 0.4.1:

 - more accurate timer support in vl.

 - more reliable NE2000 probe in vl.

 - added 2.5.66 kernel in vl-test.

			AES_encrypt(tmp, tmp, key);

			memcpy(out, tmp, AES_BLOCK_SIZE);

			memcpy(ivec, tmp, AES_BLOCK_SIZE);

	} else {

		while (len >= AES_BLOCK_SIZE) {

			memcpy(tmp, in, AES_BLOCK_SIZE);

			for(n=0; n < len; ++n)

				out[n] = tmp[n] ^ ivec[n];

			memcpy(ivec, tmp, AES_BLOCK_SIZE);

	}

}

};

/* format of the assembler string :

   %%			%

   %<bitfield>d		print the bitfield in decimal

   %<bitfield>x		print the bitfield in hex

    {0x0c400000, 0x0ff00fff, "mar%c\tacc0, %12-15r, %16-19r"},

    {0x0c500000, 0x0ff00fff, "mra%c\t%12-15r, %16-19r, acc0"},

    {0xf450f000, 0xfc70f000, "pld\t%a"},

    /* V5 Instructions.  */

    {0xe1200070, 0xfff000f0, "bkpt\t0x%16-19X%12-15X%8-11X%0-3X"},

    {0xfa000000, 0xfe000000, "blx\t%B"},

    {0xfe000010, 0xff100010, "mcr2\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},

    {0xfe100010, 0xff100010, "mrc2\t%8-11d, %21-23d, %12-15r, cr%16-19d, cr%0-3d, {%5-7d}"},

    {0x000000d0, 0x0e1000f0, "ldr%cd\t%12-15r, %s"},

    {0x000000f0, 0x0e1000f0, "str%cd\t%12-15r, %s"},

    {0x01000080, 0x0ff000f0, "smlabb%c\t%16-19r, %0-3r, %8-11r, %12-15r"},

     void * stream;

{

  func (stream, "%s", arm_regnames[given & 0xf]);

  if ((given & 0xff0) != 0)

    {

      if ((given & 0x10) == 0)

	{

	  int amount = (given & 0xf80) >> 7;

	  int shift = (given & 0x60) >> 5;

	  if (amount == 0)

	    {

	      if (shift == 3)

		  func (stream, ", rrx");

		  return;

		}

	      amount = 32;

	    }

	  func (stream, ", %s #%d", arm_shift[shift], amount);

	}

      else

      if ((given & insn->mask) == insn->value)

	{

	  char * c;

	  for (c = insn->assembler; *c; c++)

	    {

	      if (*c == '%')

			  && ((given & 0x02000000) == 0))

			{

			  int offset = given & 0xfff;

			  func (stream, "[pc");

			  if (given & 0x01000000)

			    {

			      if ((given & 0x00800000) == 0)

				offset = - offset;

			      /* Pre-indexed.  */

			      func (stream, ", #%d]", offset);

			      /* ie ignore the offset.  */

			      offset = pc + 8;

			    }

			  func (stream, "\t; ");

			  info->print_address_func (offset, info);

			}

			{

                          /* PC relative with immediate offset.  */

			  int offset = ((given & 0xf00) >> 4) | (given & 0xf);

			  if ((given & 0x00800000) == 0)

			    offset = -offset;

			  func (stream, "[pc, #%d]\t; ", offset);

			  (*info->print_address_func)

			    (offset + pc + 8, info);

			}

			    }

			}

		      break;

		    case 'b':

		      (*info->print_address_func)

			(BDISP (given) * 4 + pc + 8, info);

		      {

			bfd_vma address;

			bfd_vma offset = 0;

			if (given & 0x00800000)

			  /* Is signed, hi bits should be ones.  */

			  offset = (-1) ^ 0x00ffffff;

			offset += given & 0x00ffffff;

			offset <<= 2;

			address = offset + pc + 8;

			if (given & 0x01000000)

			  /* H bit allows addressing to 2-byte boundaries.  */

			  address += 2;

			  func (stream, "3");

			}

		      break;

		    case 'P':

		      switch (given & 0x00080080)

			{

			  {

			  case '-':

			    c++;

			    while (*c >= '0' && *c <= '9')

			      bitend = (bitend * 10) + *c++ - '0';

			    if (!bitend)

			      abort ();

			    switch (*c)

			      {

			      case 'r':

				{

				  long reg;

				  reg = given >> bitstart;

				  reg &= (2 << (bitend - bitstart)) - 1;

				  func (stream, "%s", arm_regnames[reg]);

				}

				break;

			      case 'd':

				{

				  long reg;

				  reg = given >> bitstart;

				  reg &= (2 << (bitend - bitstart)) - 1;

				  func (stream, "%d", reg);

				}

				break;

			      case 'x':

				{

				  long reg;

				  reg = given >> bitstart;

				  reg &= (2 << (bitend - bitstart)) - 1;

				  func (stream, "0x%08x", reg);

				  /* Some SWI instructions have special

				     meanings.  */

				  if ((given & 0x0fffffff) == 0x0FF00000)

			      case 'X':

				{

				  long reg;

				  reg = given >> bitstart;

				  reg &= (2 << (bitend - bitstart)) - 1;

				  func (stream, "%01x", reg & 0xf);

				}

				break;

			      case 'f':

				{

				  long reg;

				  reg = given >> bitstart;

				  reg &= (2 << (bitend - bitstart)) - 1;

				  if (reg > 7)

				    func (stream, "#%s",

					  arm_fp_const[reg & 7]);

				    }

				  break;

				default:

				  abort ();

				}

          if (!*c) /* Check for empty (not NULL) assembler string.  */

            {

	      long offset;

	      info->bytes_per_chunk = 4;

	      info->bytes_per_line  = 4;

            {

	      info->bytes_per_chunk = 2;

	      info->bytes_per_line  = 4;

              given &= 0xffff;

              for (; *c; c++)

                {

                  if (*c == '%')

                    {

                      int domaskpc = 0;

                      int domasklr = 0;

                      switch (*++c)

                        {

                        case '%':

                        case 'S':

                          {

                            long reg;

                            reg = (given >> 3) & 0x7;

                            if (given & (1 << 6))

                              reg += 8;

                            func (stream, "%s", arm_regnames[reg]);

                          }

                          break;

                        case 'D':

                          {

                            long reg;

                            reg = given & 0x7;

                            if (given & (1 << 7))

                             reg += 8;

                            func (stream, "%s", arm_regnames[reg]);

                          }

                          break;

                          {

                            int started = 0;

                            int reg;

                            func (stream, "{");

                            /* It would be nice if we could spot

                               ranges, and generate the rS-rE format: */

                            for (reg = 0; (reg < 8); reg++)

                          {

                            int bitstart = *c++ - '0';

                            int bitend = 0;

                            while (*c >= '0' && *c <= '9')

                              bitstart = (bitstart * 10) + *c++ - '0';

                              case '-':

                                {

                                  long reg;

                                  c++;

                                  while (*c >= '0' && *c <= '9')

                                    bitend = (bitend * 10) + *c++ - '0';

{

  if (option == NULL)

    return;

  if (strneq (option, "reg-names-", 10))

    {

      int i;

	    regname_selected = i;

	    break;

	  }

      if (i < 0)

	fprintf (stderr, _("Unrecognised register name set: %s\n"), option);

    }

    force_thumb = 0;

  else

    fprintf (stderr, _("Unrecognised disassembler option: %s\n"), option);

  return;

}

     char * options;

{

  char * space;

  if (options == NULL)

    return;

  if (info->disassembler_options)

    {

      parse_disassembler_options (info->disassembler_options);

      /* To avoid repeated parsing of these options, we remove them here.  */

      info->disassembler_options = NULL;

    }

  is_thumb = force_thumb;

  if (pc & 1)

    {

      is_thumb = 1;

      pc &= ~(bfd_vma) 1;

    }

#if 0

  if (!is_thumb && info->symbols != NULL)

    {

      if (bfd_asymbol_flavour (*info->symbols) == bfd_target_coff_flavour)

	{

	  coff_symbol_type * cs;

	  cs = coffsymbol (*info->symbols);

	  is_thumb = (   cs->native->u.syment.n_sclass == C_THUMBEXT

		      || cs->native->u.syment.n_sclass == C_THUMBSTAT

	{

	  elf_symbol_type *  es;

	  unsigned int       type;

	  es = *(elf_symbol_type **)(info->symbols);

	  type = ELF_ST_TYPE (es->internal_elf_sym.st_info);

	  is_thumb = (type == STT_ARM_TFUNC) || (type == STT_ARM_16BIT);

	}

    }

#endif

  little = (info->endian == BFD_ENDIAN_LITTLE);

  info->bytes_per_chunk = 4;

  info->display_endian  = little ? BFD_ENDIAN_LITTLE : BFD_ENDIAN_BIG;

      if (status != 0 && is_thumb)

	{

	  info->bytes_per_chunk = 2;

	  status = info->read_memory_func (pc, (bfd_byte *) b, 2, info);

	  b[3] = b[2] = 0;

	}

      if (status != 0)

	{

	  info->memory_error_func (status, pc, info);

	  return -1;

	}

      given = (b[0]) | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);

    }

  else

	  info->memory_error_func (status, pc, info);

	  return -1;

	}

      if (is_thumb)

	{

	  if (pc & 0x2)

	    {

	      given = (b[2] << 8) | b[3];

	      status = info->read_memory_func

		((pc + 4) & ~ 0x3, (bfd_byte *) b, 4, info);

	      if (status != 0)

		  info->memory_error_func (status, pc + 4, info);

		  return -1;

		}

	      given |= (b[0] << 24) | (b[1] << 16);

	    }

	  else

      else

	given = (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | (b[3]);

    }

  if (info->flags & INSN_HAS_RELOC)

    /* If the instruction has a reloc associated with it, then

       the offset field in the instruction will actually be the

  fprintf (stream, _("\n\

The following ARM specific disassembler options are supported for use with\n\

the -M switch:\n"));

  for (i = NUM_ARM_REGNAMES; i--;)

    fprintf (stream, "  reg-names-%s %*c%s\n",

	     regnames[i].name,

                }

                ts->heap_limit = limit;

            }

            ptr = lock_user(ARG(0), 16, 0);

            ptr[0] = tswap32(ts->heap_base);

            ptr[1] = tswap32(ts->heap_limit);

    char subtype[16]; // "Undoable" / "Volatile" / "Growing"

    uint32_t version;

    uint32_t header; // size of header

    union {

	struct {

	    uint32_t catalog; // num of entries

    char subtype[16]; // "Undoable" / "Volatile" / "Growing"

    uint32_t version;

    uint32_t header; // size of header

    union {

	struct {

	    uint32_t catalog; // num of entries

    uint32_t *catalog_bitmap;

    int catalog_size;

    int data_offset;

    int bitmap_blocks;

    int extent_blocks;

    int extent_size;

static int bochs_probe(const uint8_t *buf, int buf_size, const char *filename)

{

    const struct bochs_header *bochs = (const void *)buf;

    if (buf_size < HEADER_SIZE)

	return 0;

        if (fd < 0)

            return -1;

    }

    bs->read_only = 1; // no write support yet

    s->fd = fd;

    if (read(fd, &bochs, sizeof(bochs)) != sizeof(bochs)) {

    s->bitmap_blocks = 1 + (le32_to_cpu(bochs.extra.redolog.bitmap) - 1) / 512;

    s->extent_blocks = 1 + (le32_to_cpu(bochs.extra.redolog.extent) - 1) / 512;

    s->extent_size = le32_to_cpu(bochs.extra.redolog.extent);

    return 0;

    // seek to sector

    extent_index = offset / s->extent_size;

    extent_offset = (offset % s->extent_size) / 512;

    if (s->catalog_bitmap[extent_index] == 0xffffffff)

    {

//	fprintf(stderr, "page not allocated [%x - %x:%x]\n",

    bitmap_offset = s->data_offset + (512 * s->catalog_bitmap[extent_index] *

	(s->extent_blocks + s->bitmap_blocks));

    block_offset = bitmap_offset + (512 * (s->bitmap_blocks + extent_offset));

//    fprintf(stderr, "sect: %x [ext i: %x o: %x] -> %x bitmap: %x block: %x\n",

//	sector_num, extent_index, extent_offset,

//	le32_to_cpu(s->catalog_bitmap[extent_index]),

//	bitmap_offset, block_offset);

    // read in bitmap for current extent

    lseek(s->fd, bitmap_offset + (extent_offset / 8), SEEK_SET);

    read(s->fd, &bitmap_entry, 1);

    if (!((bitmap_entry >> (extent_offset % 8)) & 1))

    {

//	fprintf(stderr, "sector (%x) in bitmap not allocated\n",

    }

    lseek(s->fd, block_offset, SEEK_SET);

    return 0;

}

    if(inflateInit(&s->zstream) != Z_OK)

	goto cloop_close;

    s->current_block=s->n_blocks;

    s->sectors_per_block = s->block_size/512;

    bs->total_sectors = s->n_blocks*s->sectors_per_block;

    return 0;

    if(s->current_block != block_num) {

	int ret;

        uint32_t bytes = s->offsets[block_num+1]-s->offsets[block_num];

	lseek(s->fd, s->offsets[block_num], SEEK_SET);

        ret = read(s->fd, s->compressed_block, bytes);

        if (ret != bytes)

        be32_to_cpu(cow_header.version) != COW_VERSION) {

        goto fail;

    }

    /* cow image found */

    size = be64_to_cpu(cow_header.size);

    bs->total_sectors = size / 512;

    pstrcpy(bs->backing_file, sizeof(bs->backing_file),

            cow_header.backing_file);

    /* mmap the bitmap */

    s->cow_bitmap_size = ((bs->total_sectors + 7) >> 3) + sizeof(cow_header);

    s->cow_bitmap_addr = mmap(get_mmap_addr(s->cow_bitmap_size),

{

    BDRVCowState *s = bs->opaque;

    int ret, n;

    while (nb_sectors > 0) {

        if (is_changed(s->cow_bitmap, sector_num, nb_sectors, &n)) {

            lseek(s->fd, s->cow_sectors_offset + sector_num * 512, SEEK_SET);

{

    BDRVCowState *s = bs->opaque;

    int ret, i;

    lseek(s->fd, s->cow_sectors_offset + sector_num * 512, SEEK_SET);

    ret = write(s->fd, buf, nb_sectors * 512);

    if (ret != nb_sectors * 512)

typedef struct BDRVDMGState {

    int fd;

    /* each chunk contains a certain number of sectors,

     * offsets[i] is the offset in the .dmg file,

     * lengths[i] is the length of the compressed chunk,

    bs->read_only = 1;

    s->n_chunks = 0;

    s->offsets = s->lengths = s->sectors = s->sectorcounts = 0;

    /* read offset of info blocks */

    if(lseek(s->fd,-0x1d8,SEEK_END)<0) {

dmg_close:

	goto dmg_close;

    s->current_chunk = s->n_chunks;

    return 0;

}

static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)

{

    const QCowHeader *cow_header = (const void *)buf;

    if (buf_size >= sizeof(QCowHeader) &&

        be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&

        be32_to_cpu(cow_header->version) == QCOW_VERSION)

    be64_to_cpus(&header.size);

    be32_to_cpus(&header.crypt_method);

    be64_to_cpus(&header.l1_table_offset);

    if (header.magic != QCOW_MAGIC || header.version != QCOW_VERSION)

        goto fail;

    if (header.size <= 1 || header.cluster_bits < 9)

    if (!s->cluster_data)

        goto fail;

    s->cluster_cache_offset = -1;

    /* read the backing file name */

    if (header.backing_file_offset != 0) {

        len = header.backing_file_size;

    BDRVQcowState *s = bs->opaque;

    uint8_t keybuf[16];

    int len, i;

    memset(keybuf, 0, 16);

    len = strlen(key);

    if (len > 16)

    uint64_t l2_offset, *l2_table, cluster_offset, tmp;

    uint32_t min_count;

    int new_l2_table;

    l1_index = offset >> (s->l2_bits + s->cluster_bits);

    l2_offset = s->l1_table[l1_index];

    new_l2_table = 0;

    inflateEnd(strm);

    return 0;

}

static int decompress_cluster(BDRVQcowState *s, uint64_t cluster_offset)

{

    int ret, csize;

    BDRVQcowState *s = bs->opaque;

    int ret, index_in_cluster, n;

    uint64_t cluster_offset;

    while (nb_sectors > 0) {

        cluster_offset = get_cluster_offset(bs, sector_num << 9, 0, 0, 0, 0);

        index_in_cluster = sector_num & (s->cluster_sectors - 1);

    BDRVQcowState *s = bs->opaque;

    int ret, index_in_cluster, n;

    uint64_t cluster_offset;

    while (nb_sectors > 0) {

        index_in_cluster = sector_num & (s->cluster_sectors - 1);

        n = s->cluster_sectors - index_in_cluster;

        qemu_aio_release(acb);

        return;

    }

    /* prepare next AIO request */

    acb->cluster_offset = get_cluster_offset(bs, acb->sector_num << 9,

                                             0, 0, 0, 0);

    acb->buf = buf;

    acb->nb_sectors = nb_sectors;

    acb->n = 0;

    qcow_aio_read_cb(acb, 0);

    return &acb->common;

        qemu_aio_release(acb);

        return;

    }

    index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);

    acb->n = s->cluster_sectors - index_in_cluster;

    if (acb->n > acb->nb_sectors)

{

    BDRVQcowState *s = bs->opaque;

    QCowAIOCB *acb;

    s->cluster_cache_offset = -1; /* disable compressed cache */

    acb = qemu_aio_get(bs, cb, opaque);

    acb->buf = (uint8_t *)buf;

    acb->nb_sectors = nb_sectors;

    acb->n = 0;

    qcow_aio_write_cb(acb, 0);

    return &acb->common;

}

    } else {

        header.crypt_method = cpu_to_be32(QCOW_CRYPT_NONE);

    }

    /* write all the data */

    write(fd, &header, sizeof(header));

    if (backing_file) {

            return -1;

        }

    }

    qemu_free(out_buf);

    return 0;

}

  - Size of compressed clusters is stored in sectors to reduce bit usage

    in the cluster offsets.

  - Support for storing additional data (such as the VM state) in the

  - If a backing store is used, the cluster size is not constrained

    (could be backported to QCOW).

  - L2 tables have always a size of one cluster.

static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)

{

    const QCowHeader *cow_header = (const void *)buf;

    if (buf_size >= sizeof(QCowHeader) &&

        be32_to_cpu(cow_header->magic) == QCOW_MAGIC &&

        be32_to_cpu(cow_header->version) == QCOW_VERSION)

    be32_to_cpus(&header.refcount_table_clusters);

    be64_to_cpus(&header.snapshots_offset);

    be32_to_cpus(&header.nb_snapshots);

    if (header.magic != QCOW_MAGIC || header.version != QCOW_VERSION)

        goto fail;

    if (header.size <= 1 ||

    if (!s->cluster_data)

        goto fail;

    s->cluster_cache_offset = -1;

    if (refcount_init(bs) < 0)

        goto fail;

    BDRVQcowState *s = bs->opaque;

    uint8_t keybuf[16];

    int len, i;

    memset(keybuf, 0, 16);

    len = strlen(key);

    if (len > 16)

    /* write new table (align to cluster) */

    new_l1_table_offset = alloc_clusters(bs, new_l1_size2);

    for(i = 0; i < s->l1_size; i++)

        new_l1_table[i] = cpu_to_be64(new_l1_table[i]);

    ret = bdrv_pwrite(s->hd, new_l1_table_offset, new_l1_table, new_l1_size2);

        goto fail;

    for(i = 0; i < s->l1_size; i++)

        new_l1_table[i] = be64_to_cpu(new_l1_table[i]);

    /* set new table */

    data64 = cpu_to_be64(new_l1_table_offset);

    if (bdrv_pwrite(s->hd, offsetof(QCowHeader, l1_table_offset),

    BDRVQcowState *s = bs->opaque;

    int min_index, i, j, l1_index, l2_index, ret;

    uint64_t l2_offset, *l2_table, cluster_offset, tmp, old_l2_offset;

    l1_index = offset >> (s->l2_bits + s->cluster_bits);

    if (l1_index >= s->l1_size) {

        /* outside l1 table is allowed: we grow the table if needed */

           written */

        if ((n_end - n_start) < s->cluster_sectors) {

            uint64_t start_sect;

            start_sect = (offset & ~(s->cluster_size - 1)) >> 9;

            ret = copy_sectors(bs, start_sect,

                               cluster_offset, 0, n_start);

    inflateEnd(strm);

    return 0;

}

static int decompress_cluster(BDRVQcowState *s, uint64_t cluster_offset)

{

    int ret, csize, nb_csectors, sector_offset;

    BDRVQcowState *s = bs->opaque;

    int ret, index_in_cluster, n, n1;

    uint64_t cluster_offset;

    while (nb_sectors > 0) {

        cluster_offset = get_cluster_offset(bs, sector_num << 9, 0, 0, 0, 0);

        index_in_cluster = sector_num & (s->cluster_sectors - 1);

    BDRVQcowState *s = bs->opaque;

    int ret, index_in_cluster, n;

    uint64_t cluster_offset;

    while (nb_sectors > 0) {

        index_in_cluster = sector_num & (s->cluster_sectors - 1);

        n = s->cluster_sectors - index_in_cluster;

        qemu_aio_release(acb);

        return;

    }

    /* prepare next AIO request */

    acb->cluster_offset = get_cluster_offset(bs, acb->sector_num << 9,

                                             0, 0, 0, 0);

        qemu_aio_release(acb);

        return;

    }

    index_in_cluster = acb->sector_num & (s->cluster_sectors - 1);

    acb->n = s->cluster_sectors - index_in_cluster;

    if (acb->n > acb->nb_sectors)

{

    BDRVQcowState *s = bs->opaque;

    QCowAIOCB *acb;

    s->cluster_cache_offset = -1; /* disable compressed cache */

    acb = qcow_aio_setup(bs, sector_num, (uint8_t*)buf, nb_sectors, cb, opaque);

    if (!acb)

        return NULL;

    qcow_aio_write_cb(acb, 0);

    return &acb->common;

}

    QCowHeader header;

    uint64_t tmp, offset;

    QCowCreateState s1, *s = &s1;

    memset(s, 0, sizeof(*s));

    fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);

    s->refcount_block = qemu_mallocz(s->cluster_size);

    if (!s->refcount_block)

        goto fail;

    s->refcount_table_offset = offset;

    header.refcount_table_offset = cpu_to_be64(offset);

    header.refcount_table_clusters = cpu_to_be32(1);

    create_refcount_update(s, s->l1_table_offset, l1_size * sizeof(uint64_t));

    create_refcount_update(s, s->refcount_table_offset, s->cluster_size);

    create_refcount_update(s, s->refcount_block_offset, s->cluster_size);

    /* write all the data */

    write(fd, &header, sizeof(header));

    if (backing_file) {

    }

    lseek(fd, s->refcount_table_offset, SEEK_SET);

    write(fd, s->refcount_table, s->cluster_size);

    lseek(fd, s->refcount_block_offset, SEEK_SET);

    write(fd, s->refcount_block, s->cluster_size);

    ret = bdrv_truncate(s->hd, s->l1_table_offset + l1_length);

    if (ret < 0)

        return ret;

    l2_cache_reset(bs);

#endif

    return 0;

            return -1;

        }

    }

    qemu_free(out_buf);

    return 0;

}

    uint64_t *l1_table, *l2_table, l2_offset, offset, l1_size2, l1_allocated;

    int64_t old_offset, old_l2_offset;

    int l2_size, i, j, l1_modified, l2_modified, nb_csectors, refcount;

    l2_cache_reset(bs);

    l2_table = NULL;

        l1_table = s->l1_table;

        l1_allocated = 0;

    }

    l2_size = s->l2_size * sizeof(uint64_t);

    l2_table = qemu_malloc(l2_size);

    if (!l2_table)

    snapshots_offset = alloc_clusters(bs, snapshots_size);

    offset = snapshots_offset;

    for(i = 0; i < s->nb_snapshots; i++) {

        sn = s->snapshots + i;

        memset(&h, 0, sizeof(h));

        h.date_sec = cpu_to_be32(sn->date_sec);

        h.date_nsec = cpu_to_be32(sn->date_nsec);

        h.vm_clock_nsec = cpu_to_be64(sn->vm_clock_nsec);

        id_str_size = strlen(sn->id_str);

        name_size = strlen(sn->name);

        h.id_str_size = cpu_to_be16(id_str_size);

{

    BDRVQcowState *s = bs->opaque;

    int i, ret;

    ret = find_snapshot_by_id(bs, name);

    if (ret >= 0)

        return ret;

    QCowSnapshot *snapshots1, sn1, *sn = &sn1;

    int i, ret;

    uint64_t *l1_table = NULL;

    memset(sn, 0, sizeof(*sn));

    if (sn_info->id_str[0] == '\0') {

    BDRVQcowState *s = bs->opaque;

    QCowSnapshot *sn;

    int snapshot_index, ret;

    snapshot_index = find_snapshot_by_id_or_name(bs, snapshot_id);

    if (snapshot_index < 0)

        return -ENOENT;

{

    BDRVQcowState *s = bs->opaque;

    int ret, refcount_table_size2, i;

    s->refcount_block_cache = qemu_malloc(s->cluster_size);

    if (!s->refcount_block_cache)

        goto fail;

    BDRVQcowState *s = bs->opaque;

    int64_t offset, cluster_offset;

    int free_in_cluster;

    assert(size > 0 && size <= s->cluster_size);

    if (s->free_byte_offset == 0) {

        s->free_byte_offset = alloc_clusters(bs, s->cluster_size);

    BDRVQcowState *s = bs->opaque;

    int64_t start, last, cluster_offset;

    int k;

    if (size <= 0)

        return;

        goto fail;

    for(i = 0;i < l1_size; i++)

        be64_to_cpus(&l1_table[i]);

    l2_size = s->l2_size * sizeof(uint64_t);

    l2_table = qemu_malloc(l2_size);

    if (!l2_table)

    /* header */

    inc_refcounts(bs, refcount_table, nb_clusters,

                  0, s->cluster_size);

    check_refcounts_l1(bs, refcount_table, nb_clusters,

                       s->l1_table_offset, s->l1_size, 1);

{

    BDRVRawState *s = bs->opaque;

    int ret;

    ret = fd_open(bs);

    if (ret < 0)

        return ret;

{

    BDRVRawState *s = bs->opaque;

    int ret;

    ret = fd_open(bs);

    if (ret < 0)

        return ret;

    struct sigaction act;

    aio_initialized = 1;

    sigfillset(&act.sa_mask);

    act.sa_flags = 0; /* do not restart syscalls to interrupt select() */

    act.sa_handler = aio_signal_handler;

    raw_close,

    raw_create,

    raw_flush,

    .bdrv_aio_read = raw_aio_read,

    .bdrv_aio_write = raw_aio_write,

    .bdrv_aio_cancel = raw_aio_cancel,

    if ( KERN_SUCCESS != kernResult ) {

        printf( "IOMasterPort returned %d\n", kernResult );

    }

    classesToMatch = IOServiceMatching( kIOCDMediaClass );

    if ( classesToMatch == NULL ) {

        printf( "IOServiceMatching returned a NULL dictionary.\n" );

    {

        printf( "IOServiceGetMatchingServices returned %d\n", kernResult );

    }

    return kernResult;

}

        }

        IOObjectRelease( nextMedia );

    }

    return kernResult;

}

        kernResult = FindEjectableCDMedia( &mediaIterator );

        kernResult = GetBSDPath( mediaIterator, bsdPath, sizeof( bsdPath ) );

        if ( bsdPath[ 0 ] != '\0' ) {

            strcat(bsdPath,"s0");

            /* some CDs don't have a partition 0 */

            }

            filename = bsdPath;

        }

        if ( mediaIterator )

            IOObjectRelease( mediaIterator );

    }

    raw_close,

    NULL,

    raw_flush,

    .bdrv_aio_read = raw_aio_read,

    .bdrv_aio_write = raw_aio_write,

    .bdrv_aio_cancel = raw_aio_cancel,

    OVERLAPPED ov;

    DWORD ret_count;

    int ret;

    memset(&ov, 0, sizeof(ov));

    ov.Offset = offset;

    ov.OffsetHigh = offset >> 32;

    OVERLAPPED ov;

    DWORD ret_count;

    int ret;

    memset(&ov, 0, sizeof(ov));

    ov.Offset = offset;

    ov.OffsetHigh = offset >> 32;

    raw_close,

    raw_create,

    raw_flush,

#if 0

    .bdrv_aio_read = raw_aio_read,

    .bdrv_aio_write = raw_aio_write,

        }

    }

    s->type = find_device_type(bs, filename);

    if ((flags & BDRV_O_ACCESS) == O_RDWR) {

        access_flags = GENERIC_READ | GENERIC_WRITE;

    } else {

    raw_close,

    NULL,

    raw_flush,

#if 0

    .bdrv_aio_read = raw_aio_read,

    .bdrv_aio_write = raw_aio_write,

#define CHECK_CID 1

#define DESC_SIZE 20*SECTOR_SIZE	// 20 sectors of 512 bytes each

#define HEADER_SIZE 512   			// first sector of 512 bytes

    fail_gd:

    qemu_free(gd_buf);

    qemu_free(rgd_buf);

    fail:

    close(p_fd);

        p_name += sizeof("parentFileNameHint") + 1;

        if ((end_name = strchr(p_name,'\"')) == 0)

            return -1;

        strncpy(s->hd->backing_file, p_name, end_name - p_name);

        if (stat(s->hd->backing_file, &file_buf) != 0) {

            path_combine(parent_img_name, sizeof(parent_img_name),

    header.check_bytes[1] = 0x20;

    header.check_bytes[2] = 0xd;

    header.check_bytes[3] = 0xa;

    write(fd, &magic, sizeof(magic));

    write(fd, &header, sizeof(header));

    for (i = 0, tmp = header.rgd_offset + gd_size;

         i < gt_count; i++, tmp += gt_size)

        write(fd, &tmp, sizeof(tmp));

    /* write backup grain directory */

    lseek(fd, le64_to_cpu(header.gd_offset) << 9, SEEK_SET);

    for (i = 0, tmp = header.gd_offset + gd_size;

typedef struct BDRVVPCState {

    int fd;

    int pagetable_entries;

    uint32_t *pagetable;

    uint8_t *pageentry_u8;

    uint32_t *pageentry_u32;

    uint16_t *pageentry_u16;

    uint64_t last_bitmap;

#endif

} BDRVVPCState;

        return -1;

    bs->read_only = 1; // no write support yet

    s->fd = fd;

    if (read(fd, &header, HEADER_SIZE) != HEADER_SIZE)

    pagetable_index = offset / s->pageentry_size;

    pageentry_index = (offset % s->pageentry_size) / 512;

    if (pagetable_index > s->pagetable_entries || s->pagetable[pagetable_index] == 0xffffffff)

	return -1; // not allocated

    bitmap_offset = 512 * s->pagetable[pagetable_index];

    block_offset = bitmap_offset + 512 + (512 * pageentry_index);

//    printf("sector: %" PRIx64 ", index: %x, offset: %x, bioff: %" PRIx64 ", bloff: %" PRIx64 "\n",

//	sector_num, pagetable_index, pageentry_index,

//	bitmap_offset, block_offset);

	    index_to<0 || index_to>=array->next ||

	    index_from<0 || index_from>=array->next)

	return -1;

    if(index_to==index_from)

	return 0;

	memmove(to+is*count,to,from-to);

    else

	memmove(from,from+is*count,to-from);

    memcpy(to,buf,is*count);

    free(buf);

    BlockDriverState* bs; /* pointer to parent */

    unsigned int first_sectors_number; /* 1 for a single partition, 0x40 for a disk with partition table */

    unsigned char first_sectors[0x40*0x200];

    int fat_type; /* 16 or 32 */

    array_t fat,directory,mapping;

    unsigned int cluster_size;

    unsigned int sectors_per_cluster;

    unsigned int sectors_per_fat;

    uint32_t sector_count; /* total number of sectors of the partition */

    uint32_t cluster_count; /* total number of clusters of this partition */

    uint32_t max_fat_value;

    int current_fd;

    mapping_t* current_mapping;

    unsigned char* cluster; /* points to current cluster */

    partition_t* partition=&(real_mbr->partition[0]);

    memset(s->first_sectors,0,512);

    partition->attributes=0x80; /* bootable */

    partition->start_head=1;

    partition->start_sector=1;

    for(i=0;i<11;i++)

	chksum=(((chksum&0xfe)>>1)|((chksum&0x01)?0x80:0))