block/raw-win32.c

   1 /*
   2  * Block driver for RAW files (win32)
   3  *
   4  * Copyright (c) 2006 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "qemu-common.h"
  25 #include "qemu-timer.h"
  26 #include "block_int.h"
  27 #include "module.h"
  28 #include <windows.h>
  29 #include <winioctl.h>
  30
  31 #define FTYPE_FILE 0
  32 #define FTYPE_CD     1
  33 #define FTYPE_HARDDISK 2
  34
  35 typedef struct BDRVRawState {
  36     HANDLE hfile;
  37     int type;
  38     char drive_path[16]; /* format: "d:\" */
  39 } BDRVRawState;
  40
  41 int qemu_ftruncate64(int fd, int64_t length)
  42 {
  43     LARGE_INTEGER li;
  44     DWORD dw;
  45     LONG high;
  46     HANDLE h;
  47     BOOL res;
  48
  49     if ((GetVersion() & 0x80000000UL) && (length >> 32) != 0)
  50         return -1;
  51
  52     h = (HANDLE)_get_osfhandle(fd);
  53
  54     /* get current position, ftruncate do not change position */
  55     li.HighPart = 0;
  56     li.LowPart = SetFilePointer (h, 0, &li.HighPart, FILE_CURRENT);
  57     if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
  58         return -1;
  59     }
  60
  61     high = length >> 32;
  62     dw = SetFilePointer(h, (DWORD) length, &high, FILE_BEGIN);
  63     if (dw == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR) {
  64         return -1;
  65     }
  66     res = SetEndOfFile(h);
  67
  68     /* back to old position */
  69     SetFilePointer(h, li.LowPart, &li.HighPart, FILE_BEGIN);
  70     return res ? 0 : -1;
  71 }
  72
  73 static int set_sparse(int fd)
  74 {
  75     DWORD returned;
  76     return (int) DeviceIoControl((HANDLE)_get_osfhandle(fd), FSCTL_SET_SPARSE,
  77                                  NULL, 0, NULL, 0, &returned, NULL);
  78 }
  79
  80 static int raw_open(BlockDriverState *bs, const char *filename, int flags)
  81 {
  82     BDRVRawState *s = bs->opaque;
  83     int access_flags;
  84     DWORD overlapped;
  85
  86     s->type = FTYPE_FILE;
  87
  88     if (flags & BDRV_O_RDWR) {
  89         access_flags = GENERIC_READ | GENERIC_WRITE;
  90     } else {
  91         access_flags = GENERIC_READ;
  92     }
  93
  94     overlapped = FILE_ATTRIBUTE_NORMAL;
  95     if (flags & BDRV_O_NOCACHE)
  96         overlapped |= FILE_FLAG_NO_BUFFERING;
  97     if (!(flags & BDRV_O_CACHE_WB))
  98         overlapped |= FILE_FLAG_WRITE_THROUGH;
  99     s->hfile = CreateFile(filename, access_flags,
 100                           FILE_SHARE_READ, NULL,
 101                           OPEN_EXISTING, overlapped, NULL);
 102     if (s->hfile == INVALID_HANDLE_VALUE) {
 103         int err = GetLastError();
 104
 105         if (err == ERROR_ACCESS_DENIED)
 106             return -EACCES;
 107         return -1;
 108     }
 109     return 0;
 110 }
 111
 112 static int raw_read(BlockDriverState *bs, int64_t sector_num,
 113                     uint8_t *buf, int nb_sectors)
 114 {
 115     BDRVRawState *s = bs->opaque;
 116     OVERLAPPED ov;
 117     DWORD ret_count;
 118     int ret;
 119     int64_t offset = sector_num * 512;
 120     int count = nb_sectors * 512;
 121
 122     memset(&ov, 0, sizeof(ov));
 123     ov.Offset = offset;
 124     ov.OffsetHigh = offset >> 32;
 125     ret = ReadFile(s->hfile, buf, count, &ret_count, &ov);
 126     if (!ret)
 127         return ret_count;
 128     if (ret_count == count)
 129         ret_count = 0;
 130     return ret_count;
 131 }
 132
 133 static int raw_write(BlockDriverState *bs, int64_t sector_num,
 134                      const uint8_t *buf, int nb_sectors)
 135 {
 136     BDRVRawState *s = bs->opaque;
 137     OVERLAPPED ov;
 138     DWORD ret_count;
 139     int ret;
 140     int64_t offset = sector_num * 512;
 141     int count = nb_sectors * 512;
 142
 143     memset(&ov, 0, sizeof(ov));
 144     ov.Offset = offset;
 145     ov.OffsetHigh = offset >> 32;
 146     ret = WriteFile(s->hfile, buf, count, &ret_count, &ov);
 147     if (!ret)
 148         return ret_count;
 149     if (ret_count == count)
 150         ret_count = 0;
 151     return ret_count;
 152 }
 153
 154 static int raw_flush(BlockDriverState *bs)
 155 {
 156     BDRVRawState *s = bs->opaque;
 157     int ret;
 158
 159     ret = FlushFileBuffers(s->hfile);
 160     if (ret == 0) {
 161         return -EIO;
 162     }
 163
 164     return 0;
 165 }
 166
 167 static void raw_close(BlockDriverState *bs)
 168 {
 169     BDRVRawState *s = bs->opaque;
 170     CloseHandle(s->hfile);
 171 }
 172
 173 static int raw_truncate(BlockDriverState *bs, int64_t offset)
 174 {
 175     BDRVRawState *s = bs->opaque;
 176     LONG low, high;
 177
 178     low = offset;
 179     high = offset >> 32;
 180     if (!SetFilePointer(s->hfile, low, &high, FILE_BEGIN))
 181         return -EIO;
 182     if (!SetEndOfFile(s->hfile))
 183         return -EIO;
 184     return 0;
 185 }
 186
 187 static int64_t raw_getlength(BlockDriverState *bs)
 188 {
 189     BDRVRawState *s = bs->opaque;
 190     LARGE_INTEGER l;
 191     ULARGE_INTEGER available, total, total_free;
 192     DISK_GEOMETRY_EX dg;
 193     DWORD count;
 194     BOOL status;
 195
 196     switch(s->type) {
 197     case FTYPE_FILE:
 198         l.LowPart = GetFileSize(s->hfile, (PDWORD)&l.HighPart);
 199         if (l.LowPart == 0xffffffffUL && GetLastError() != NO_ERROR)
 200             return -EIO;
 201         break;
 202     case FTYPE_CD:
 203         if (!GetDiskFreeSpaceEx(s->drive_path, &available, &total, &total_free))
 204             return -EIO;
 205         l.QuadPart = total.QuadPart;
 206         break;
 207     case FTYPE_HARDDISK:
 208         status = DeviceIoControl(s->hfile, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX,
 209                                  NULL, 0, &dg, sizeof(dg), &count, NULL);
 210         if (status != 0) {
 211             l = dg.DiskSize;
 212         }
 213         break;
 214     default:
 215         return -EIO;
 216     }
 217     return l.QuadPart;
 218 }
 219
 220 static int64_t raw_get_allocated_file_size(BlockDriverState *bs)
 221 {
 222     typedef DWORD (WINAPI * get_compressed_t)(const char *filename,
 223                                               DWORD * high);
 224     get_compressed_t get_compressed;
 225     struct _stati64 st;
 226     const char *filename = bs->filename;
 227     /* WinNT support GetCompressedFileSize to determine allocate size */
 228     get_compressed =
 229         (get_compressed_t) GetProcAddress(GetModuleHandle("kernel32"),
 230                                             "GetCompressedFileSizeA");
 231     if (get_compressed) {
 232         DWORD high, low;
 233         low = get_compressed(filename, &high);
 234         if (low != 0xFFFFFFFFlu || GetLastError() == NO_ERROR) {
 235             return (((int64_t) high) << 32) + low;
 236         }
 237     }
 238
 239     if (_stati64(filename, &st) < 0) {
 240         return -1;
 241     }
 242     return st.st_size;
 243 }
 244
 245 static int raw_create(const char *filename, QEMUOptionParameter *options)
 246 {
 247     int fd;
 248     int64_t total_size = 0;
 249
 250     /* Read out options */
 251     while (options && options->name) {
 252         if (!strcmp(options->name, BLOCK_OPT_SIZE)) {
 253             total_size = options->value.n / 512;
 254         }
 255         options++;
 256     }
 257
 258     fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
 259               0644);
 260     if (fd < 0)
 261         return -EIO;
 262     set_sparse(fd);
 263     ftruncate(fd, total_size * 512);
 264     close(fd);
 265     return 0;
 266 }
 267
 268 static QEMUOptionParameter raw_create_options[] = {
 269     {
 270         .name = BLOCK_OPT_SIZE,
 271         .type = OPT_SIZE,
 272         .help = "Virtual disk size"
 273     },
 274     { NULL }
 275 };
 276
 277 static BlockDriver bdrv_file = {
 278     .format_name        = "file",
 279     .protocol_name      = "file",
 280     .instance_size      = sizeof(BDRVRawState),
 281     .bdrv_file_open     = raw_open,
 282     .bdrv_close         = raw_close,
 283     .bdrv_create        = raw_create,
 284
 285     .bdrv_read              = raw_read,
 286     .bdrv_write             = raw_write,
 287     .bdrv_co_flush_to_disk  = raw_flush,
 288
 289     .bdrv_truncate      = raw_truncate,
 290     .bdrv_getlength     = raw_getlength,
 291     .bdrv_get_allocated_file_size
 292                         = raw_get_allocated_file_size,
 293
 294     .create_options = raw_create_options,
 295 };
 296
 297 /***********************************************/
 298 /* host device */
 299
 300 static int find_cdrom(char *cdrom_name, int cdrom_name_size)
 301 {
 302     char drives[256], *pdrv = drives;
 303     UINT type;
 304
 305     memset(drives, 0, sizeof(drives));
 306     GetLogicalDriveStrings(sizeof(drives), drives);
 307     while(pdrv[0] != '\0') {
 308         type = GetDriveType(pdrv);
 309         switch(type) {
 310         case DRIVE_CDROM:
 311             snprintf(cdrom_name, cdrom_name_size, "\\\\.\\%c:", pdrv[0]);
 312             return 0;
 313             break;
 314         }
 315         pdrv += lstrlen(pdrv) + 1;
 316     }
 317     return -1;
 318 }
 319
 320 static int find_device_type(BlockDriverState *bs, const char *filename)
 321 {
 322     BDRVRawState *s = bs->opaque;
 323     UINT type;
 324     const char *p;
 325
 326     if (strstart(filename, "\\\\.\\", &p) ||
 327         strstart(filename, "//./", &p)) {
 328         if (stristart(p, "PhysicalDrive", NULL))
 329             return FTYPE_HARDDISK;
 330         snprintf(s->drive_path, sizeof(s->drive_path), "%c:\\", p[0]);
 331         type = GetDriveType(s->drive_path);
 332         switch (type) {
 333         case DRIVE_REMOVABLE:
 334         case DRIVE_FIXED:
 335             return FTYPE_HARDDISK;
 336         case DRIVE_CDROM:
 337             return FTYPE_CD;
 338         default:
 339             return FTYPE_FILE;
 340         }
 341     } else {
 342         return FTYPE_FILE;
 343     }
 344 }
 345
 346 static int hdev_probe_device(const char *filename)
 347 {
 348     if (strstart(filename, "/dev/cdrom", NULL))
 349         return 100;
 350     if (is_windows_drive(filename))
 351         return 100;
 352     return 0;
 353 }
 354
 355 static int hdev_open(BlockDriverState *bs, const char *filename, int flags)
 356 {
 357     BDRVRawState *s = bs->opaque;
 358     int access_flags, create_flags;
 359     DWORD overlapped;
 360     char device_name[64];
 361
 362     if (strstart(filename, "/dev/cdrom", NULL)) {
 363         if (find_cdrom(device_name, sizeof(device_name)) < 0)
 364             return -ENOENT;
 365         filename = device_name;
 366     } else {
 367         /* transform drive letters into device name */
 368         if (((filename[0] >= 'a' && filename[0] <= 'z') ||
 369              (filename[0] >= 'A' && filename[0] <= 'Z')) &&
 370             filename[1] == ':' && filename[2] == '\0') {
 371             snprintf(device_name, sizeof(device_name), "\\\\.\\%c:", filename[0]);
 372             filename = device_name;
 373         }
 374     }
 375     s->type = find_device_type(bs, filename);
 376
 377     if (flags & BDRV_O_RDWR) {
 378         access_flags = GENERIC_READ | GENERIC_WRITE;
 379     } else {
 380         access_flags = GENERIC_READ;
 381     }
 382     create_flags = OPEN_EXISTING;
 383
 384     overlapped = FILE_ATTRIBUTE_NORMAL;
 385     if (flags & BDRV_O_NOCACHE)
 386         overlapped |= FILE_FLAG_NO_BUFFERING;
 387     if (!(flags & BDRV_O_CACHE_WB))
 388         overlapped |= FILE_FLAG_WRITE_THROUGH;
 389     s->hfile = CreateFile(filename, access_flags,
 390                           FILE_SHARE_READ, NULL,
 391                           create_flags, overlapped, NULL);
 392     if (s->hfile == INVALID_HANDLE_VALUE) {
 393         int err = GetLastError();
 394
 395         if (err == ERROR_ACCESS_DENIED)
 396             return -EACCES;
 397         return -1;
 398     }
 399     return 0;
 400 }
 401
 402 static int hdev_has_zero_init(BlockDriverState *bs)
 403 {
 404     return 0;
 405 }
 406
 407 static BlockDriver bdrv_host_device = {
 408     .format_name        = "host_device",
 409     .protocol_name      = "host_device",
 410     .instance_size      = sizeof(BDRVRawState),
 411     .bdrv_probe_device  = hdev_probe_device,
 412     .bdrv_file_open     = hdev_open,
 413     .bdrv_close         = raw_close,
 414     .bdrv_has_zero_init = hdev_has_zero_init,
 415
 416     .bdrv_read              = raw_read,
 417     .bdrv_write             = raw_write,
 418     .bdrv_co_flush_to_disk  = raw_flush,
 419
 420     .bdrv_getlength     = raw_getlength,
 421     .bdrv_get_allocated_file_size
 422                         = raw_get_allocated_file_size,
 423 };
 424
 425 static void bdrv_file_init(void)
 426 {
 427     bdrv_register(&bdrv_file);
 428     bdrv_register(&bdrv_host_device);
 429 }
 430
 431 block_init(bdrv_file_init);