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 static uint64_t offset = 0;
  43
  44 /**@brief   IO block size.*/
  45 #define EXT4_IORAW_BSIZE 512
  46
  47 /**@brief   Image file descriptor.*/
  48 static HANDLE dev_file;
  49
  50 /**********************BLOCKDEV INTERFACE**************************************/
  51 static int io_raw_open(struct ext4_blockdev *bdev);
  52 static int io_raw_bread(struct ext4_blockdev *bdev, void *buf, uint64_t blk_id,
  53                         uint32_t blk_cnt);
  54 static int io_raw_bwrite(struct ext4_blockdev *bdev, const void *buf,
  55                          uint64_t blk_id, uint32_t blk_cnt);
  56 static int io_raw_close(struct ext4_blockdev *bdev);
  57
  58 /******************************************************************************/
  59 EXT4_BLOCKDEV_STATIC_INSTANCE(_filedev, EXT4_IORAW_BSIZE, 0, io_raw_open,
  60                               io_raw_bread, io_raw_bwrite, io_raw_close, 0, 0);
  61
  62 /******************************************************************************/
  63 static int io_raw_open(struct ext4_blockdev *bdev)
  64 {
  65         char path[64];
  66         DISK_GEOMETRY pdg;
  67         uint64_t disk_size;
  68         BOOL bResult = FALSE;
  69         DWORD junk;
  70
  71         sprintf(path, "\\\\.\\%s", fname);
  72
  73         dev_file =
  74             CreateFile(path, GENERIC_READ | GENERIC_WRITE,
  75                        FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, OPEN_EXISTING,
  76                        FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH, NULL);
  77
  78         if (dev_file == INVALID_HANDLE_VALUE) {
  79                 return EIO;
  80         }
  81
  82         bResult =
  83             DeviceIoControl(dev_file, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
  84                             &pdg, sizeof(pdg), &junk, (LPOVERLAPPED)NULL);
  85
  86         if (bResult == FALSE) {
  87                 CloseHandle(dev_file);
  88                 return EIO;
  89         }
  90
  91         disk_size = pdg.Cylinders.QuadPart * (ULONG)pdg.TracksPerCylinder *
  92                     (ULONG)pdg.SectorsPerTrack * (ULONG)pdg.BytesPerSector;
  93
  94         _filedev.bdif->ph_bsize = pdg.BytesPerSector;
  95         _filedev.bdif->ph_bcnt = disk_size / pdg.BytesPerSector;
  96
  97         _filedev.part_offset = offset;
  98         _filedev.part_size = disk_size;
  99
 100         return EOK;
 101 }
 102
 103 /******************************************************************************/
 104
 105 static int io_raw_bread(struct ext4_blockdev *bdev, void *buf, uint64_t blk_id,
 106                         uint32_t blk_cnt)
 107 {
 108         long hipart = blk_id >> (32 - 9);
 109         long lopart = blk_id << 9;
 110         long err;
 111
 112         SetLastError(0);
 113         lopart = SetFilePointer(dev_file, lopart, &hipart, FILE_BEGIN);
 114
 115         if (lopart == -1 && NO_ERROR != (err = GetLastError())) {
 116                 return EIO;
 117         }
 118
 119         DWORD n;
 120
 121         if (!ReadFile(dev_file, buf, blk_cnt * 512, &n, NULL)) {
 122                 err = GetLastError();
 123                 return EIO;
 124         }
 125         return EOK;
 126 }
 127
 128 /******************************************************************************/
 129 static int io_raw_bwrite(struct ext4_blockdev *bdev, const void *buf,
 130                          uint64_t blk_id, uint32_t blk_cnt)
 131 {
 132         long hipart = blk_id >> (32 - 9);
 133         long lopart = blk_id << 9;
 134         long err;
 135
 136         SetLastError(0);
 137         lopart = SetFilePointer(dev_file, lopart, &hipart, FILE_BEGIN);
 138
 139         if (lopart == -1 && NO_ERROR != (err = GetLastError())) {
 140                 return EIO;
 141         }
 142
 143         DWORD n;
 144
 145         if (!WriteFile(dev_file, buf, blk_cnt * 512, &n, NULL)) {
 146                 err = GetLastError();
 147                 return EIO;
 148         }
 149         return EOK;
 150 }
 151
 152 /******************************************************************************/
 153 static int io_raw_close(struct ext4_blockdev *bdev)
 154 {
 155         CloseHandle(dev_file);
 156         return EOK;
 157 }
 158
 159 /******************************************************************************/
 160 struct ext4_blockdev *ext4_io_raw_dev_get(void) { return &_filedev; }
 161 /******************************************************************************/
 162 void ext4_io_raw_filename(const char *n) { fname = n; }
 163 void ext4_io_raw_offset(uint64_t o) { offset = o; }
 164
 165 /******************************************************************************/
 166 #endif