blockdev/windows/io_raw.c

   1 /*
   2  * Copyright (c) 2013 Grzegorz Kostka (kostka.grzegorz@gmail.com)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <ext4_config.h>
  30 #include <ext4_blockdev.h>
  31 #include <ext4_errno.h>
  32 #include <stdio.h>
  33 #include <stdbool.h>
  34 #include <string.h>
  35
  36 #ifdef WIN32
  37 #include <windows.h>
  38 #include <winioctl.h>
  39
  40 /**@brief   Default filename.*/
  41 static const char *fname = "ext2";
  42
  43 /**@brief   IO block size.*/
  44 #define EXT4_IORAW_BSIZE 512
  45
  46 /**@brief   Image file descriptor.*/
  47 static HANDLE dev_file;
  48
  49 /**********************BLOCKDEV INTERFACE**************************************/
  50 static int io_raw_open(struct ext4_blockdev *bdev);
  51 static int io_raw_bread(struct ext4_blockdev *bdev, void *buf, uint64_t blk_id,
  52                         uint32_t blk_cnt);
  53 static int io_raw_bwrite(struct ext4_blockdev *bdev, const void *buf,
  54                          uint64_t blk_id, uint32_t blk_cnt);
  55 static int io_raw_close(struct ext4_blockdev *bdev);
  56
  57 /******************************************************************************/
  58 EXT4_BLOCKDEV_STATIC_INSTANCE(_filedev, EXT4_IORAW_BSIZE, 0, io_raw_open,
  59                               io_raw_bread, io_raw_bwrite, io_raw_close, 0, 0);
  60
  61 /******************************************************************************/
  62 static int io_raw_open(struct ext4_blockdev *bdev)
  63 {
  64         char path[64];
  65         DISK_GEOMETRY pdg;
  66         uint64_t disk_size;
  67         BOOL bResult = FALSE;
  68         DWORD junk;
  69
  70         sprintf(path, "\\\\.\\%s", fname);
  71
  72         dev_file =
  73             CreateFile(path, GENERIC_READ | GENERIC_WRITE,
  74                        FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, OPEN_EXISTING,
  75                        FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH, NULL);
  76
  77         if (dev_file == INVALID_HANDLE_VALUE) {
  78                 return EIO;
  79         }
  80
  81         bResult =
  82             DeviceIoControl(dev_file, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
  83                             &pdg, sizeof(pdg), &junk, (LPOVERLAPPED)NULL);
  84
  85         if (bResult == FALSE) {
  86                 CloseHandle(dev_file);
  87                 return EIO;
  88         }
  89
  90         disk_size = pdg.Cylinders.QuadPart * (ULONG)pdg.TracksPerCylinder *
  91                     (ULONG)pdg.SectorsPerTrack * (ULONG)pdg.BytesPerSector;
  92
  93         _filedev.bdif->ph_bsize = pdg.BytesPerSector;
  94         _filedev.bdif->ph_bcnt = disk_size / pdg.BytesPerSector;
  95
  96         _filedev.part_offset = 0;
  97         _filedev.part_size = disk_size;
  98
  99         return EOK;
 100 }
 101
 102 /******************************************************************************/
 103
 104 static int io_raw_bread(struct ext4_blockdev *bdev, void *buf, uint64_t blk_id,
 105                         uint32_t blk_cnt)
 106 {
 107         long hipart = blk_id >> (32 - 9);
 108         long lopart = blk_id << 9;
 109         long err;
 110
 111         SetLastError(0);
 112         lopart = SetFilePointer(dev_file, lopart, &hipart, FILE_BEGIN);
 113
 114         if (lopart == -1 && NO_ERROR != (err = GetLastError())) {
 115                 return EIO;
 116         }
 117
 118         DWORD n;
 119
 120         if (!ReadFile(dev_file, buf, blk_cnt * 512, &n, NULL)) {
 121                 err = GetLastError();
 122                 return EIO;
 123         }
 124         return EOK;
 125 }
 126
 127 /******************************************************************************/
 128 static int io_raw_bwrite(struct ext4_blockdev *bdev, const void *buf,
 129                          uint64_t blk_id, uint32_t blk_cnt)
 130 {
 131         long hipart = blk_id >> (32 - 9);
 132         long lopart = blk_id << 9;
 133         long err;
 134
 135         SetLastError(0);
 136         lopart = SetFilePointer(dev_file, lopart, &hipart, FILE_BEGIN);
 137
 138         if (lopart == -1 && NO_ERROR != (err = GetLastError())) {
 139                 return EIO;
 140         }
 141
 142         DWORD n;
 143
 144         if (!WriteFile(dev_file, buf, blk_cnt * 512, &n, NULL)) {
 145                 err = GetLastError();
 146                 return EIO;
 147         }
 148         return EOK;
 149 }
 150
 151 /******************************************************************************/
 152 static int io_raw_close(struct ext4_blockdev *bdev)
 153 {
 154         CloseHandle(dev_file);
 155         return EOK;
 156 }
 157
 158 /******************************************************************************/
 159 struct ext4_blockdev *ext4_io_raw_dev_get(void) { return &_filedev; }
 160 /******************************************************************************/
 161 void ext4_io_raw_filename(const char *n) { fname = n; }
 162
 163 /******************************************************************************/
 164 #endif