1: /*
    2:  * Block driver for Parallels disk image format
    3:  *
    4:  * Copyright (c) 2007 Alex Beregszaszi
    5:  *
    6:  * This code is based on comparing different disk images created by Parallels.
    7:  *
    8:  * Permission is hereby granted, free of charge, to any person obtaining a copy
    9:  * of this software and associated documentation files (the "Software"), to deal
   10:  * in the Software without restriction, including without limitation the rights
   11:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   12:  * copies of the Software, and to permit persons to whom the Software is
   13:  * furnished to do so, subject to the following conditions:
   14:  *
   15:  * The above copyright notice and this permission notice shall be included in
   16:  * all copies or substantial portions of the Software.
   17:  *
   18:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   19:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   20:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   21:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   22:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   23:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   24:  * THE SOFTWARE.
   25:  */
   26: #include "qemu-common.h"
   27: #include "block_int.h"
   28: 
   29: /**************************************************************/
   30: 
   31: #define HEADER_MAGIC "WithoutFreeSpace"
   32: #define HEADER_VERSION 2
   33: #define HEADER_SIZE 64
   34: 
   35: // always little-endian
   36: struct parallels_header {
   37:     char magic[16]; // "WithoutFreeSpace"
   38:     uint32_t version;
   39:     uint32_t heads;
   40:     uint32_t cylinders;
   41:     uint32_t tracks;
   42:     uint32_t catalog_entries;
   43:     uint32_t nb_sectors;
   44:     char padding[24];
   45: } __attribute__((packed));
   46: 
   47: typedef struct BDRVParallelsState {
   48:     int fd;
   49: 
   50:     uint32_t *catalog_bitmap;
   51:     int catalog_size;
   52: 
   53:     int tracks;
   54: } BDRVParallelsState;
   55: 
   56: static int parallels_probe(const uint8_t *buf, int buf_size, const char *filename)
   57: {
   58:     const struct parallels_header *ph = (const void *)buf;
   59: 
   60:     if (buf_size < HEADER_SIZE)
   61:         return 0;
   62: 
   63:     if (!memcmp(ph->magic, HEADER_MAGIC, 16) &&
   64:         (le32_to_cpu(ph->version) == HEADER_VERSION))
   65:         return 100;
   66: 
   67:     return 0;
   68: }
   69: 
   70: static int parallels_open(BlockDriverState *bs, const char *filename, int flags)
   71: {
   72:     BDRVParallelsState *s = bs->opaque;
   73:     int fd, i;
   74:     struct parallels_header ph;
   75: 
   76:     fd = open(filename, O_RDWR | O_BINARY | O_LARGEFILE);
   77:     if (fd < 0) {
   78:         fd = open(filename, O_RDONLY | O_BINARY | O_LARGEFILE);
   79:         if (fd < 0)
   80:             return -1;
   81:     }
   82: 
   83:     bs->read_only = 1; // no write support yet
   84: 
   85:     s->fd = fd;
   86: 
   87:     if (read(fd, &ph, sizeof(ph)) != sizeof(ph))
   88:         goto fail;
   89: 
   90:     if (memcmp(ph.magic, HEADER_MAGIC, 16) ||
   91:         (le32_to_cpu(ph.version) != HEADER_VERSION)) {
   92:         goto fail;
   93:     }
   94: 
   95:     bs->total_sectors = le32_to_cpu(ph.nb_sectors);
   96: 
   97:     if (lseek(s->fd, 64, SEEK_SET) != 64)
   98:         goto fail;
   99: 
  100:     s->tracks = le32_to_cpu(ph.tracks);
  101: 
  102:     s->catalog_size = le32_to_cpu(ph.catalog_entries);
  103:     s->catalog_bitmap = qemu_malloc(s->catalog_size * 4);
  104:     if (!s->catalog_bitmap)
  105:         goto fail;
  106:     if (read(s->fd, s->catalog_bitmap, s->catalog_size * 4) !=
  107:         s->catalog_size * 4)
  108:         goto fail;
  109:     for (i = 0; i < s->catalog_size; i++)
  110:         le32_to_cpus(&s->catalog_bitmap[i]);
  111: 
  112:     return 0;
  113: fail:
  114:     if (s->catalog_bitmap)
  115:         qemu_free(s->catalog_bitmap);
  116:     close(fd);
  117:     return -1;
  118: }
  119: 
  120: static inline int seek_to_sector(BlockDriverState *bs, int64_t sector_num)
  121: {
  122:     BDRVParallelsState *s = bs->opaque;
  123:     uint32_t index, offset, position;
  124: 
  125:     index = sector_num / s->tracks;
  126:     offset = sector_num % s->tracks;
  127: 
  128:     // not allocated
  129:     if ((index > s->catalog_size) || (s->catalog_bitmap[index] == 0))
  130:         return -1;
  131: 
  132:     position = (s->catalog_bitmap[index] + offset) * 512;
  133: 
  134: //    fprintf(stderr, "sector: %llx index=%x offset=%x pointer=%x position=%x\n",
  135: //      sector_num, index, offset, s->catalog_bitmap[index], position);
  136: 
  137:     if (lseek(s->fd, position, SEEK_SET) != position)
  138:         return -1;
  139: 
  140:     return 0;
  141: }
  142: 
  143: static int parallels_read(BlockDriverState *bs, int64_t sector_num,
  144:                     uint8_t *buf, int nb_sectors)
  145: {
  146:     BDRVParallelsState *s = bs->opaque;
  147: 
  148:     while (nb_sectors > 0) {
  149:         if (!seek_to_sector(bs, sector_num)) {
  150:             if (read(s->fd, buf, 512) != 512)
  151:                 return -1;
  152:         } else
  153:             memset(buf, 0, 512);
  154:         nb_sectors--;
  155:         sector_num++;
  156:         buf += 512;
  157:     }
  158:     return 0;
  159: }
  160: 
  161: static void parallels_close(BlockDriverState *bs)
  162: {
  163:     BDRVParallelsState *s = bs->opaque;
  164:     qemu_free(s->catalog_bitmap);
  165:     close(s->fd);
  166: }
  167: 
  168: BlockDriver bdrv_parallels = {
  169:     "parallels",
  170:     sizeof(BDRVParallelsState),
  171:     parallels_probe,
  172:     parallels_open,
  173:     parallels_read,
  174:     NULL,
  175:     parallels_close,
  176: };