diskio-windows.cc revision 6aae2a9b70e9f88926baad94c1eea40e0b534f01 
1//
2// C++ Interface: diskio (Windows-specific components)
3//
4// Description: Class to handle low-level disk I/O for GPT fdisk
5//
6//
7// Author: Rod Smith <rodsmith@rodsbooks.com>, (C) 2009
8//
9// Copyright: See COPYING file that comes with this distribution
10//
11//
12// This program is copyright (c) 2009, 2010 by Roderick W. Smith. It is distributed
13// under the terms of the GNU GPL version 2, as detailed in the COPYING file.
14
15#define __STDC_LIMIT_MACROS
16#define __STDC_CONSTANT_MACROS
17
18#include <windows.h>
19#include <winioctl.h>
20#define fstat64 fstat
21#define stat64 stat
22#define S_IRGRP 0
23#define S_IROTH 0
24#include <stdio.h>
25#include <string>
26#include <stdint.h>
27#include <errno.h>
28#include <fcntl.h>
29#include <sys/stat.h>
30#include <iostream>
31
32#include "support.h"
33#include "diskio.h"
34
35using namespace std;
36
37// Returns the official Windows name for a shortened version of same.
38void DiskIO::MakeRealName(void) {
39   size_t colonPos;
40
41   colonPos = userFilename.find(':', 0);
42   if ((colonPos != string::npos) && (colonPos <= 3)) {
43      realFilename = "\\\\.\\physicaldrive";
44      realFilename += userFilename.substr(0, colonPos);
45   } else {
46      realFilename = userFilename;
47   } // if/else
48} // DiskIO::MakeRealName()
49
50// Open the currently on-record file for reading
51int DiskIO::OpenForRead(void) {
52   int shouldOpen = 1;
53
54   if (isOpen) { // file is already open
55      if (openForWrite) {
56         Close();
57      } else {
58         shouldOpen = 0;
59      } // if/else
60   } // if
61
62   if (shouldOpen) {
63      fd = CreateFile(realFilename.c_str(),GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
64                      NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
65      if (fd == INVALID_HANDLE_VALUE) {
66         CloseHandle(fd);
67         cerr << "Problem opening " << realFilename << " for reading!\n";
68         realFilename = "";
69         userFilename = "";
70         isOpen = 0;
71         openForWrite = 0;
72      } else {
73         isOpen = 1;
74         openForWrite = 0;
75      } // if/else
76   } // if
77
78   return isOpen;
79} // DiskIO::OpenForRead(void)
80
81// An extended file-open function. This includes some system-specific checks.
82// Returns 1 if the file is open, 0 otherwise....
83int DiskIO::OpenForWrite(void) {
84   if ((isOpen) && (openForWrite))
85      return 1;
86
87   // Close the disk, in case it's already open for reading only....
88   Close();
89
90   // try to open the device; may fail....
91   fd = CreateFile(realFilename.c_str(), GENERIC_READ | GENERIC_WRITE,
92                   FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
93                   FILE_ATTRIBUTE_NORMAL, NULL);
94   // Preceding call can fail when creating backup files; if so, try
95   // again with different option...
96   if (fd == INVALID_HANDLE_VALUE) {
97      CloseHandle(fd);
98      fd = CreateFile(realFilename.c_str(), GENERIC_READ | GENERIC_WRITE,
99                      FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS,
100                      FILE_ATTRIBUTE_NORMAL, NULL);
101   } // if
102   if (fd == INVALID_HANDLE_VALUE) {
103      CloseHandle(fd);
104      isOpen = 0;
105      openForWrite = 0;
106      errno = GetLastError();
107   } else {
108      isOpen = 1;
109      openForWrite = 1;
110   } // if/else
111   return isOpen;
112} // DiskIO::OpenForWrite(void)
113
114// Close the disk device. Note that this does NOT erase the stored filenames,
115// so the file can be re-opened without specifying the filename.
116void DiskIO::Close(void) {
117   if (isOpen)
118      CloseHandle(fd);
119   isOpen = 0;
120   openForWrite = 0;
121} // DiskIO::Close()
122
123// Returns block size of device pointed to by fd file descriptor. If the ioctl
124// returns an error condition, assume it's a disk file and return a value of
125// SECTOR_SIZE (512). If the disk can't be opened at all, return a value of 0.
126int DiskIO::GetBlockSize(void) {
127   DWORD blockSize = 0, retBytes;
128   DISK_GEOMETRY_EX geom;
129
130   // If disk isn't open, try to open it....
131   if (!isOpen) {
132      OpenForRead();
133   } // if
134
135   if (isOpen) {
136      if (DeviceIoControl(fd, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL, 0,
137                          &geom, sizeof(geom), &retBytes, NULL)) {
138         blockSize = geom.Geometry.BytesPerSector;
139      } else { // was probably an ordinary file; set default value....
140         blockSize = SECTOR_SIZE;
141      } // if/else
142   } // if (isOpen)
143
144   return (blockSize);
145} // DiskIO::GetBlockSize()
146
147// Returns the number of heads, according to the kernel, or 255 if the
148// correct value can't be determined.
149uint32_t DiskIO::GetNumHeads(void) {
150   return UINT32_C(255);
151} // DiskIO::GetNumHeads();
152
153// Returns the number of sectors per track, according to the kernel, or 63
154// if the correct value can't be determined.
155uint32_t DiskIO::GetNumSecsPerTrack(void) {
156   return UINT32_C(63);
157} // DiskIO::GetNumSecsPerTrack()
158
159// Resync disk caches so the OS uses the new partition table. This code varies
160// a lot from one OS to another.
161void DiskIO::DiskSync(void) {
162   DWORD i;
163   GET_LENGTH_INFORMATION buf;
164
165   // If disk isn't open, try to open it....
166   if (!openForWrite) {
167      OpenForWrite();
168   } // if
169
170   if (isOpen) {
171      if (DeviceIoControl(fd, IOCTL_DISK_UPDATE_PROPERTIES, NULL, 0, &buf, sizeof(buf), &i, NULL) == 0) {
172         cout << "Disk synchronization failed! The computer may use the old partition table\n"
173              << "until you reboot or remove and re-insert the disk!\n";
174      } else {
175         cout << "Disk synchronization succeeded! The computer should now use the new\n"
176              << "partition table.\n";
177      } // if/else
178   } else {
179      cout << "Unable to open the disk for synchronization operation! The computer will\n"
180           << "continue to use the old partition table until you reboot or remove and\n"
181           << "re-insert the disk!\n";
182   } // if (isOpen)
183} // DiskIO::DiskSync()
184
185// Seek to the specified sector. Returns 1 on success, 0 on failure.
186int DiskIO::Seek(uint64_t sector) {
187   int retval = 1;
188   LARGE_INTEGER seekTo;
189
190   // If disk isn't open, try to open it....
191   if (!isOpen) {
192      retval = OpenForRead();
193   } // if
194
195   if (isOpen) {
196      seekTo.QuadPart = sector * (uint64_t) GetBlockSize();
197      retval = SetFilePointerEx(fd, seekTo, NULL, FILE_BEGIN);
198      if (retval == 0) {
199         errno = GetLastError();
200         cerr << "Error when seeking to " << seekTo.QuadPart << "! Error is " << errno << "\n";
201         retval = 0;
202      } // if
203   } // if
204   return retval;
205} // DiskIO::Seek()
206
207// A variant on the standard read() function. Done to work around
208// limitations in FreeBSD concerning the matching of the sector
209// size with the number of bytes read.
210// Returns the number of bytes read into buffer.
211int DiskIO::Read(void* buffer, int numBytes) {
212   int blockSize = 512, i, numBlocks;
213   char* tempSpace;
214   DWORD retval = 0;
215
216   // If disk isn't open, try to open it....
217   if (!isOpen) {
218      OpenForRead();
219   } // if
220
221   if (isOpen) {
222      // Compute required space and allocate memory
223      blockSize = GetBlockSize();
224      if (numBytes <= blockSize) {
225         numBlocks = 1;
226         tempSpace = new char [blockSize];
227      } else {
228         numBlocks = numBytes / blockSize;
229         if ((numBytes % blockSize) != 0)
230            numBlocks++;
231         tempSpace = new char [numBlocks * blockSize];
232      } // if/else
233      if (tempSpace == NULL) {
234         cerr << "Unable to allocate memory in DiskIO::Read()! Terminating!\n";
235         exit(1);
236      } // if
237
238      // Read the data into temporary space, then copy it to buffer
239      ReadFile(fd, tempSpace, numBlocks * blockSize, &retval, NULL);
240      for (i = 0; i < numBytes; i++) {
241         ((char*) buffer)[i] = tempSpace[i];
242      } // for
243
244      // Adjust the return value, if necessary....
245      if (((numBlocks * blockSize) != numBytes) && (retval > 0))
246         retval = numBytes;
247
248      delete[] tempSpace;
249   } // if (isOpen)
250   return retval;
251} // DiskIO::Read()
252
253// A variant on the standard write() function. Done to work around
254// limitations in FreeBSD concerning the matching of the sector
255// size with the number of bytes read.
256// Returns the number of bytes written.
257int DiskIO::Write(void* buffer, int numBytes) {
258   int blockSize = 512, i, numBlocks, retval = 0;
259   char* tempSpace;
260   DWORD numWritten;
261
262   // If disk isn't open, try to open it....
263   if ((!isOpen) || (!openForWrite)) {
264      OpenForWrite();
265   } // if
266
267   if (isOpen) {
268      // Compute required space and allocate memory
269      blockSize = GetBlockSize();
270      if (numBytes <= blockSize) {
271         numBlocks = 1;
272         tempSpace = new char [blockSize];
273      } else {
274         numBlocks = numBytes / blockSize;
275         if ((numBytes % blockSize) != 0) numBlocks++;
276         tempSpace = new char [numBlocks * blockSize];
277      } // if/else
278      if (tempSpace == NULL) {
279         cerr << "Unable to allocate memory in DiskIO::Write()! Terminating!\n";
280         exit(1);
281      } // if
282
283      // Copy the data to my own buffer, then write it
284      for (i = 0; i < numBytes; i++) {
285         tempSpace[i] = ((char*) buffer)[i];
286      } // for
287      for (i = numBytes; i < numBlocks * blockSize; i++) {
288         tempSpace[i] = 0;
289      } // for
290      WriteFile(fd, tempSpace, numBlocks * blockSize, &numWritten, NULL);
291      retval = (int) numWritten;
292
293      // Adjust the return value, if necessary....
294      if (((numBlocks * blockSize) != numBytes) && (retval > 0))
295         retval = numBytes;
296
297      delete[] tempSpace;
298   } // if (isOpen)
299   return retval;
300} // DiskIO:Write()
301
302// Returns the size of the disk in blocks.
303uint64_t DiskIO::DiskSize(int *err) {
304   uint64_t sectors = 0; // size in sectors
305   DWORD bytes, moreBytes; // low- and high-order bytes of file size
306   GET_LENGTH_INFORMATION buf;
307   DWORD i;
308
309   // If disk isn't open, try to open it....
310   if (!isOpen) {
311      OpenForRead();
312   } // if
313
314   if (isOpen) {
315      // Note to self: I recall testing a simplified version of
316      // this code, similar to what's in the __APPLE__ block,
317      // on Linux, but I had some problems. IIRC, it ran OK on 32-bit
318      // systems but not on 64-bit. Keep this in mind in case of
319      // 32/64-bit issues on MacOS....
320      if (DeviceIoControl(fd, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &buf, sizeof(buf), &i, NULL)) {
321         sectors = (uint64_t) buf.Length.QuadPart / GetBlockSize();
322         *err = 0;
323      } else { // doesn't seem to be a disk device; assume it's an image file....
324         bytes = GetFileSize(fd, &moreBytes);
325         sectors = ((uint64_t) bytes + ((uint64_t) moreBytes) * UINT32_MAX) / GetBlockSize();
326         *err = 0;
327      } // if
328   } else {
329      *err = -1;
330      sectors = 0;
331   } // if/else (isOpen)
332
333   return sectors;
334} // DiskIO::DiskSize()
335